{"version":3,"sources":["webpack:///4.4.bundle.js","webpack:///./app/devices/devices.resolver.ts?e580","webpack:///./app/devices/devices.service.ts?f749","webpack:///./app/devices/devices.module.ts?72f4","webpack:///./app/devices/device-list/device-list.component.ts?0616","webpack:///./app/devices/device-list/device-list.template.html?25d7","webpack:///./app/devices/device-list/device-list.style.scss?7344","webpack:///./app/devices/device/device.component.ts?68d8","webpack:///./app/devices/device.model.ts?fbbb","webpack:///./app/devices/device/device.template.html?a0b7","webpack:///./app/devices/device/device.style.scss?fa2c","webpack:///./app/devices/device-widgets/device-widget.component.ts?bd44","webpack:///./app/devices/device-widgets/device-widget.template.html?2cca","webpack:///./app/devices/device-widgets/device-widget.style.scss?d9b4","webpack:///./app/devices/device-widgets/device-widget.service.ts?17ce","webpack:///../~/socket.io-client/lib/index.js?af7e","webpack:///../~/socket.io-client/lib/url.js?246b","webpack:///../~/parseuri/index.js?70dd","webpack:///../~/socket.io-client/~/debug/debug.js?0b60","webpack:///../~/ms/index.js?6d06","webpack:///../~/socket.io-parser/index.js?498b","webpack:///../~/socket.io-parser/~/debug/browser.js?7e42","webpack:///../~/socket.io-parser/~/debug/debug.js?40c4","webpack:///../~/socket.io-parser/~/ms/index.js?7829","webpack:///../~/json3/lib/json3.js?371c","webpack:///../~/webpack/buildin/module.js?17a8","webpack:///../~/webpack/buildin/amd-options.js?668d","webpack:///../~/component-emitter/index.js?7cb9","webpack:///../~/socket.io-parser/binary.js?751b","webpack:///../~/socket.io-parser/~/isarray/index.js?30f3","webpack:///../~/socket.io-parser/is-buffer.js?2594","webpack:///../~/socket.io-client/lib/manager.js?f5ed","webpack:///../~/engine.io-client/index.js?ab54","webpack:///../~/engine.io-client/lib/index.js?cd7b","webpack:///../~/engine.io-client/lib/socket.js?db9a","webpack:///../~/engine.io-client/lib/transports/index.js?5010","webpack:///../~/engine.io-client/lib/xmlhttprequest.js?a923","webpack:///../~/has-cors/index.js?4024","webpack:///../~/engine.io-client/lib/transports/polling-xhr.js?8a01","webpack:///../~/engine.io-client/lib/transports/polling.js?90ea","webpack:///../~/engine.io-client/lib/transport.js?7185","webpack:///../~/engine.io-parser/lib/browser.js?0e40","webpack:///../~/engine.io-parser/lib/keys.js?46e1","webpack:///../~/has-binary/index.js?45ea","webpack:///../~/arraybuffer.slice/index.js?a2bd","webpack:///../~/after/index.js?0210","webpack:///../~/wtf-8/wtf-8.js?7716","webpack:///../~/base64-arraybuffer/lib/base64-arraybuffer.js?1911","webpack:///../~/blob/index.js?249c","webpack:///../~/engine.io-client/~/component-emitter/index.js?27e3","webpack:///../~/parseqs/index.js?5ed4","webpack:///../~/component-inherit/index.js?85f5","webpack:///../~/yeast/index.js?1f48","webpack:///../~/engine.io-client/lib/transports/polling-jsonp.js?7cb5","webpack:///../~/engine.io-client/lib/transports/websocket.js?b5ab","webpack:///../~/indexof/index.js?b472","webpack:///../~/parsejson/index.js?eb42","webpack:///../~/socket.io-client/lib/socket.js?1a25","webpack:///../~/to-array/index.js?e840","webpack:///../~/socket.io-client/lib/on.js?4583","webpack:///../~/component-bind/index.js?c74c","webpack:///../~/backo2/index.js?c27a","webpack:///./app/devices/device-widgets/servo-widget/servo-widget.component.ts?5b3c","webpack:///./app/devices/device-widgets/shared/base-output-sensor/base-output-sensor.ts?32fb","webpack:///./app/devices/device-widgets/shared/base-sensor/base-sensor.ts?f4d4","webpack:///./app/devices/device-widgets/servo-widget/servo-widget.template.html?7d8a","webpack:///./app/devices/device-widgets/servo-widget/servo-widget.style.scss?a74d","webpack:///./app/devices/device-widgets/switcher-widget/switcher-widget.component.ts?9f0a","webpack:///./app/devices/device-widgets/switcher-widget/switcher-widget.template.html?0857","webpack:///./app/devices/device-widgets/switcher-widget/switcher-widget.style.scss?cfcb","webpack:///./app/devices/device-widgets/sensor-widget/sensor-widget.component.ts?04d2","webpack:///./app/devices/device-widgets/sensor-widget/sensor-widget.template.html?25e8","webpack:///./app/scenarios/scenarios.module.ts","webpack:///./app/scenarios/scenarios.routing.ts","webpack:///./app/scenarios/scenario-details/editor/create-scenario-editor/create-scenario-editor.component.ts","webpack:///./app/scenarios/shared/scenario.service.ts","webpack:///./app/scenarios/scenario-details/scenario-details.component.ts","webpack:///./app/scenarios/scenario-details/wizard/scenario-entities/scenario.ts","webpack:///./app/scenarios/scenario-details/scenario-details.template.html","webpack:///./app/scenarios/scenario-details/scenario-details.style.scss","webpack:///./app/scenarios/scenario-details/editor/create-scenario-editor/create-scenario-editor.template.html","webpack:///./app/scenarios/scenario-details/editor/create-scenario-editor/scenario-editor.style.scss","webpack:///./app/scenarios/scenario-details/editor/edit-scenario-editor/edit-scenario-editor.component.ts","webpack:///./app/scenarios/scenario-details/wizard/create-scenario-wizard/create-scenario-wizard.component.ts","webpack:///./app/scenarios/scenario-details/wizard/scenario-entities/action.ts","webpack:///./app/scenarios/scenario-details/wizard/scenario-entities/condition.ts","webpack:///./app/scenarios/scenario-details/wizard/create-scenario-wizard/create-scenario-wizard.template.html","webpack:///./app/scenarios/scenario-details/wizard/edit-scenario-wizard/edit-scenario-wizard.component.ts","webpack:///./app/scenarios/scenario-details/wizard/edit-scenario-wizard/edit-scenario-wizard.template.html","webpack:///./app/scenarios/scenarios-list/scenario-list.component.ts","webpack:///./app/scenarios/scenarios-list/scenario-status.service.ts","webpack:///./app/scenarios/scenarios-list/scenario-list.template.html","webpack:///./app/scenarios/scenarios-list/scenario-list.style.scss","webpack:///./app/scenarios/scenarios-list/scenario-list.resolve.service.ts","webpack:///./app/scenarios/scenarios.declarations.ts","webpack:///./app/scenarios/scenario-details/editor/scenario-editor/scenario-editor.component.ts","webpack:///../~/codemirror/lib/codemirror.css?6dfb","webpack:///../~/codemirror/lib/codemirror.css","webpack:///../~/css-loader/lib/css-base.js","webpack:///../~/style-loader/addStyles.js","webpack:///../~/codemirror/theme/lesser-dark.css?b76f","webpack:///../~/codemirror/theme/lesser-dark.css","webpack:///../~/codemirror/lib/codemirror.js","webpack:///../~/codemirror/addon/edit/matchbrackets.js","webpack:///../~/codemirror/addon/edit/closebrackets.js","webpack:///../~/codemirror/mode/javascript/javascript.js","webpack:///./app/scenarios/scenario-details/editor/scenario-editor/code-mirror-events.const.ts","webpack:///./app/scenarios/scenario-details/wizard/scenario-wizard/scenario-wizard.component.ts","webpack:///./app/scenarios/scenario-details/wizard/scenario-entities/logical-operators.const.ts","webpack:///./app/scenarios/scenario-details/wizard/scenario-wizard/scenario-wizard.template.html","webpack:///./app/scenarios/scenario-details/wizard/scenario-wizard/scenario-wizard.style.scss","webpack:///../~/socket.io-client/~/debug/browser.js?785a"],"names":["webpackJsonp","419","module","exports","__webpack_require__","__decorate","this","decorators","target","key","desc","d","c","arguments","length","r","Object","getOwnPropertyDescriptor","Reflect","decorate","i","defineProperty","__metadata","k","v","metadata","core_1","devices_service_1","DeviceListResolver","devicesService","prototype","resolve","getSensors","Injectable","_a","DevicesService","420","sh_http_service_1","http","get","id","save","sensor","post","update","put","_id","delete","ShHttpService","434","router_1","forms_1","shared_module_1","device_list_component_1","device_component_1","device_widget_component_1","devices_resolver_1","device_widget_service_1","servo_widget_component_1","switcher_widget_component_1","sensor_widget_component_1","DevicesModule","NgModule","imports","RouterModule","FormsModule","SharedModule","declarations","DeviceWidgetComponent","SensorWidgetComponent","SwitcherWidgetComponent","ServoWidgetComponent","DeviceListComponent","DeviceComponent","providers","DeviceWidgetService","435","dialog_service_1","headersForDisplay","topic","name","sortable","dialogService","viewContainerRef","router","editOnItemClick","showDeleteButton","statisticLink","sortBy","reverse","_headers","setSortBy","sortByValue","_this","deviceList","sort","a","b","isActive","val","getItemEditLink","goToDeviceStatistic","mqttId","type","$event","stopPropagation","navigate","removeSensor","item","confirmOptions","title","message","confirm","filter","isConfirmed","subscribe","data","elem","enumerable","configurable","Input","Boolean","String","Component","selector","template","styles","_b","DialogService","_c","ViewContainerRef","_d","Router","436","437","438","device_model_1","switcher","switchSensor","device","executor","switcherImageUrl","Device","439","assign","subType","description","440","441","442","isEditMode","onRemoveWidget","EventEmitter","removeWidget","emit","Output","443","444","445","io","setupSocket","socket","connect","backEndUrl","backEndWebSocketUrl","callback","activateDevice","on","connected","apply","unsubscribe","pushEvent","config","446","lookup","uri","opts","undefined","parsed","url","source","path","sameNamespace","cache","nsps","newConnection","forceNew","multiplex","debug","Manager","query","encodeQueryString","obj","str","p","hasOwnProperty","push","encodeURIComponent","join","parser","managers","protocol","Socket","447","global","loc","location","host","charAt","test","parseuri","port","ipv6","indexOf","href","call","448","re","parts","src","e","substring","replace","m","exec","authority","ipv6uri","449","450","selectColor","colors","prevColor","namespace","disabled","enabled","self","curr","Date","ms","prevTime","diff","prev","useColors","color","args","Array","coerce","concat","index","match","format","formatter","formatters","splice","formatArgs","logFn","log","console","bind","fn","enable","namespaces","split","len","skips","RegExp","substr","names","disable","Error","stack","humanize","451","parse","n","parseFloat","toLowerCase","y","h","s","fmtShort","Math","round","fmtLong","plural","floor","ceil","options","isNaN","long","JSON","stringify","452","Encoder","encodeAsString","nsp","BINARY_EVENT","BINARY_ACK","attachments","json","encodeAsBinary","writeEncoding","bloblessData","deconstruction","binary","deconstructPacket","pack","packet","buffers","unshift","removeBlobs","Decoder","reconstructor","decodeString","Number","types","error","buf","next","tryParse","BinaryReconstructor","reconPack","ERROR","Emitter","isBuf","CONNECT","DISCONNECT","EVENT","ACK","encode","encoding","add","base64","takeBinaryData","destroy","finishedReconstruction","binData","reconstructPacket","453","document","documentElement","style","window","firebug","exception","table","navigator","userAgent","parseInt","$1","slice","lastC","Function","storage","removeItem","load","localstorage","localStorage","chrome","local","j","454","455","short","456","__WEBPACK_AMD_DEFINE_RESULT__","runInContext","context","has","undef","isSupported","value","serialized","stringifySupported","isExtended","toJSON","getClass","parseSupported","root","SyntaxError","TypeError","nativeJSON","isProperty","forEach","objectProto","toString","getUTCFullYear","getUTCMonth","getUTCDate","getUTCHours","getUTCMinutes","getUTCSeconds","getUTCMilliseconds","functionClass","dateClass","numberClass","stringClass","arrayClass","booleanClass","charIndexBuggy","Months","getDay","year","month","property","constructor","members","__proto__","original","result","parent","object","Properties","size","valueOf","isFunction","isConstructor","hasProperty","objectTypes","Escapes","92","34","8","12","10","13","9","leadingZeroes","toPaddedString","width","unicodePrefix","quote","useCharIndex","symbols","charCode","charCodeAt","serialize","properties","whitespace","indentation","className","date","time","hours","minutes","seconds","milliseconds","results","element","prefix","pop","Index","Source","fromCharCode","Unescapes","47","98","116","110","102","114","abort","lex","begin","position","isSigned","hasMembers","walk","isLoader","function","freeExports","nodeType","freeGlobal","previousJSON","isRestored","JSON3","noConflict","457","webpackPolyfill","deprecate","paths","children","458","__webpack_amd_options__","459","mixin","addEventListener","event","_callbacks","once","off","removeListener","removeAllListeners","removeEventListener","callbacks","cb","listeners","hasListeners","460","isArray","_deconstructPacket","placeholder","_placeholder","num","newData","packetData","_reconstructPacket","_removeBlobs","curKey","containingObject","Blob","File","pendingBlobs","fileReader","FileReader","onload","readAsArrayBuffer","461","arr","462","Buffer","isBuffer","ArrayBuffer","463","subs","reconnection","reconnectionAttempts","Infinity","reconnectionDelay","reconnectionDelayMax","randomizationFactor","backoff","Backoff","min","max","jitter","timeout","readyState","connecting","lastPing","packetBuffer","encoder","decoder","autoConnect","open","eio","emitAll","updateSocketIds","engine","_reconnection","_reconnectionAttempts","_reconnectionDelay","setMin","_randomizationFactor","setJitter","_reconnectionDelayMax","setMax","_timeout","maybeReconnectOnOpen","reconnecting","attempts","reconnect","skipReconnect","openSub","onopen","errorSub","cleanup","err","timer","setTimeout","close","clearTimeout","onping","onpong","ondata","ondecoded","onerror","onConnecting","encodedPackets","write","processPacketQueue","shift","subsLength","sub","disconnect","reset","onclose","reason","delay","duration","onreconnect","attempt","464","465","466","hostname","secure","agent","parseqs","decode","upgrade","forceJSONP","jsonp","forceBase64","enablesXDR","timestampParam","timestampRequests","transports","writeBuffer","prevBufferLen","policyPort","rememberUpgrade","binaryType","onlyBinaryUpgrades","perMessageDeflate","threshold","pfx","passphrase","cert","ca","ciphers","rejectUnauthorized","forceNode","extraHeaders","keys","localAddress","upgrades","pingInterval","pingTimeout","pingIntervalTimer","pingTimeoutTimer","clone","o","parsejson","priorWebsocketSuccess","Transport","createTransport","EIO","transport","sid","setTransport","onDrain","onPacket","onError","onClose","probe","onTransportOpen","upgradeLosesBinary","supportsBinary","failed","send","msg","upgrading","pause","flush","freezeTransport","onTransportClose","onupgrade","to","onOpen","l","onHandshake","setPing","code","filterUpgrades","onHeartbeat","ping","sendPacket","writable","compress","cleanupAndClose","waitForUpgrade","filteredUpgrades","467","polling","xhr","xd","xs","isSSL","xdomain","xscheme","XMLHttpRequest","XHR","JSONP","websocket","468","hasCORS","XDomainRequest","469","470","empty","Polling","requestTimeout","Request","method","async","isBinary","create","unloadHandler","requests","inherit","request","doWrite","req","sendXhr","doPoll","onData","pollXhr","setDisableHeaderCheck","setRequestHeader","responseType","withCredentials","hasXDR","onLoad","responseText","onreadystatechange","status","requestsCount","onSuccess","fromError","contentType","getResponseHeader","response","Uint8Array","ui8Arr","dataArray","idx","attachEvent","471","hasXHR2","yeast","doOpen","poll","onPause","total","decodePayload","doClose","packets","callbackfn","encodePayload","schema","b64","472","decodePacket","473","encodeBase64Object","encodeArrayBuffer","encodeBase64Packet","contentArray","resultBuffer","byteLength","buffer","encodeBlobAsArrayBuffer","fr","encodePacket","encodeBlob","dontSendBlobs","blob","tryDecode","utf8","map","ary","each","done","after","eachWithIndex","el","base64encoder","hasBinary","sliceBuffer","isAndroid","isPhantomJS","pong","noop","packetslist","utf8encode","encoded","readAsDataURL","b64data","typed","basic","btoa","utf8decode","decodeBase64Packet","asArray","rest","setLengthHeader","encodeOne","doneCallback","encodePayloadAsBlob","encodePayloadAsArrayBuffer","decodePayloadAsBinary","chr","ret","totalLength","reduce","acc","resultArray","bufferIndex","isString","ab","view","lenStr","binaryIdentifier","lengthAry","bufferTail","numberTooLong","tailArray","msgLength","474","475","_hasBinary","476","477","arraybuffer","start","end","bytes","abv","ii","478","count","err_cb","proxy","bail","479","ucs2decode","string","extra","output","counter","ucs2encode","array","stringFromCharCode","createByte","codePoint","encodeCodePoint","symbol","wtf8encode","codePoints","byteString","readContinuationByte","byteIndex","byteCount","continuationByte","byteArray","decodeSymbol","byte1","byte2","byte3","byte4","wtf8decode","tmp","wtf8","version","480","chars","encoded1","encoded2","encoded3","encoded4","bufferLength","481","mapArrayBufferViews","chunk","copy","set","byteOffset","BlobBuilderConstructor","bb","BlobBuilder","append","getBlob","BlobConstructor","WebKitBlobBuilder","MSBlobBuilder","MozBlobBuilder","blobSupported","blobSupportsArrayBufferView","blobBuilderSupported","482","483","qs","qry","pairs","pair","decodeURIComponent","484","485","alphabet","decoded","now","seed","486","487","488","JSONPPolling","___eio","script","rNewline","rEscapedNewline","parentNode","removeChild","form","iframe","createElement","insertAt","getElementsByTagName","insertBefore","head","body","appendChild","isUAgecko","complete","initIframe","html","iframeId","area","top","left","setAttribute","action","submit","489","WS","usingBrowserWebSocket","BrowserWebSocket","WebSocket","NodeWebSocket","MozWebSocket","check","protocols","headers","ws","supports","addEventListeners","onmessage","ev","490","491","492","rvalidchars","rvalidescape","rvalidtokens","rvalidbraces","rtrimLeft","rtrimRight","493","ids","acks","receiveBuffer","sendBuffer","disconnected","toArray","hasBin","events","connect_error","connect_timeout","reconnect_attempt","reconnect_failed","reconnect_error","subEvents","parserType","flags","onpacket","onconnect","onevent","onack","ondisconnect","ack","sent","emitBuffered","494","495","list","496","497","498","factor","pow","rand","random","deviation","499","__extends","__","base_output_sensor_1","_super","sensorWidgetService","changeDegree","BaseOutputSensor","500","base_sensor_1","DEVICE_ON_STATE","DEVICE_OFF_STATE","DEVICE_RESPOND_TIMEOUT","pending","Symbol","getConditionResult","condition","f","generateValue","positiveValue","negativeValue","toDeviceRepresentation","fromDeviceRepresentation","onDeviceDataChanged","rawValue","updateTime","BaseSensor","501","ngOnInit","valueUpdated","ngOnDestroy","502","503","504","switchExecutor","checked","505","506","507","508","562","devices_module_1","scenarios_routing_1","scenario_list_resolve_service_1","scenario_status_service_1","scenario_service_1","scenarios_declarations_1","ScenariosModule","routing","default","ScenarioListResolveService","ScenarioStatusService","ScenarioService","563","create_scenario_editor_component_1","edit_scenario_editor_component_1","create_scenario_wizard_component_1","edit_scenario_wizard_component_1","scenario_list_component_1","routes","component","ScenarioListComponent","scenarioList","CreateScenarioEditorComponent","CreateScenarioWizardComponent","EditScenarioEditorComponent","EditScenarioWizardComponent","forChild","564","scenario_details_component_1","_scenarioService","_route","_router","scenario","back","onScenarioBodyUpdate","scenarioBody","ActivatedRoute","ScenarioDetailsComponent","565","getScenario","isWizard","mapScenario","cleanScenario","sourceType","wizard","getConditions","_conditions","selectedDevice","selectedCondition","getActions","_actions","logicalOperator","conditions","actions","isConvertable","566","scenario_1","Scenario","567","DEFAULT_SCENARIO_STATE","active","568","569","570","571","572","scenarioListService","route","snapshot","params","isWizardAvailable","_e","573","action_1","condition_1","devices","newScenario","Condition","Action","onAddCriteria","onRemoveCriteria","onAddAction","onRemoveAction","574","initOptions","values","575","sign","576","577","Rx_1","mapConditions","mapActions","deviceListStream","scenarioStream","Observable","forkJoin","_f","578","579","SCENARIO_ACTIVE_STATE","SCENARIO_PAUSED_STATE","scenarioService","scenarioStatusService","convertScenarioStatus","subscription","onScenarioStatusChange","scenarioToChange","find","removeScenario","toggleScenarioState","scenarioForUpdate","navigateToEditView","580","SCENARIO_STATUS_CHANGE_EVENT","setup","stream","observer","581","582","583","584","scenario_editor_component_1","scenario_wizard_component_1","ScenarioEditorComponent","ScenarioWizardComponent","585","CodeMirror","code_mirror_events_const_1","updateScenario","codeMirror","ngAfterViewInit","initCodeEditor","ngOnChanges","codeEditor","getValue","setValue","codeEditorElement","nativeElement","mode","lineNumbers","autoCloseBrackets","matchBrackets","tabSize","theme","initListeners","changeObj","origin","SET_VALUE_EVENT","ViewChild","586","content","locals","587","588","modules","mediaQuery","alreadyImportedModules","589","addStylesToDom","domStyle","stylesInDom","refs","addStyle","listToStyles","newStyles","css","media","sourceMap","part","insertStyleElement","styleElement","getHeadElement","lastStyleElementInsertedAtTop","styleElementsInsertedAtTop","nextSibling","firstChild","removeStyleElement","createStyleElement","createLinkElement","linkElement","rel","remove","singleton","styleIndex","singletonCounter","singletonElement","applyToSingletonTag","URL","createObjectURL","revokeObjectURL","updateLink","applyToTag","newObj","styleSheet","cssText","replaceText","cssNode","createTextNode","childNodes","unescape","oldSrc","memoize","memo","isOldIE","newList","mayRemove","textStore","replacement","590","591","592","factory","classTest","cls","removeChildren","removeChildrenAndAdd","elt","tag","contains","child","activeElt","activeElement","addClass","node","current","joinClasses","as","copyObj","overwrite","prop","countColumn","startIndex","startValue","search","nextTab","findColumn","goal","pos","col","skipped","spaceStr","spaceStrs","lst","out","insertSorted","score","priority","nothing","createObj","base","props","inst","isWordCharBasic","ch","toUpperCase","nonASCIISingleCaseWordChar","isWordChar","helper","isEmpty","isExtendingChar","extendingChars","skipExtendingChars","dir","findFirst","pred","from","abs","mid","Display","place","doc","input","scrollbarFiller","gutterFiller","lineDiv","selectionDiv","cursorDiv","measure","lineMeasure","lineSpace","mover","sizer","sizerWidth","heightForcer","scrollerGap","gutters","lineGutter","scroller","wrapper","ie","ie_version","zIndex","paddingRight","webkit","gecko","mobile","draggable","viewFrom","viewTo","first","reportedViewFrom","reportedViewTo","renderedView","externalMeasured","viewOffset","lastWrapHeight","lastWrapWidth","updateLineNumbers","nativeBarWidth","barHeight","barWidth","scrollbarsClipped","lineNumWidth","lineNumInnerWidth","lineNumChars","alignWidgets","cachedCharWidth","cachedTextHeight","cachedPaddingH","maxLine","maxLineLength","maxLineChanged","wheelDX","wheelDY","wheelStartX","wheelStartY","selForContextMenu","activeTouch","init","getLine","lines","sz","chunkSize","getBetween","line","iter","text","getLines","updateLineHeight","height","lineNo","cur","no","lineAtHeight","outer","i$1","lh","isLine","lineNumberFor","lineNumberFormatter","firstLineNumber","Pos","sticky","cmp","equalCursorPos","copyPos","x","maxPos","minPos","clipLine","clipPos","last","clipToLen","linelen","clipPosArray","seeReadOnlySpans","sawReadOnlySpans","seeCollapsedSpans","sawCollapsedSpans","MarkedSpan","marker","getMarkedSpanFor","spans","span","removeMarkedSpan","addMarkedSpan","markedSpans","attachLine","markedSpansBefore","old","startCh","isInsert","nw","startsBefore","inclusiveLeft","insertLeft","endsAfter","inclusiveRight","markedSpansAfter","endCh","stretchSpansOverChange","change","full","oldFirst","oldLast","sameLine","offset","found","span$1","found$1","clearEmptySpans","newMarkers","gapMarkers","gap","i$2","i$3","clearWhenEmpty","removeReadOnlyRanges","markers","mark","readOnly","mk","newParts","dfrom","dto","detachMarkedSpans","detachLine","attachMarkedSpans","extraLeft","extraRight","compareCollapsedMarkers","lenDiff","aPos","bPos","fromCmp","toCmp","collapsedSpanAtSide","sps","sp","collapsed","collapsedSpanAtStart","collapsedSpanAtEnd","conflictingCollapsedRange","visualLine","merged","visualLineEnd","visualLineContinued","visualLineNo","lineN","vis","visualLineEndNo","lastLine","lineIsHidden","widgetNode","lineIsHiddenInner","heightAtLine","lineObj","lineLength","findMaxLine","cm","display","iterateBidiSections","order","level","getBidiPartAt","bidiOther","getOrder","bidiOrdering","moveCharLogically","moveLogically","endOfLine","visually","moveInStorageOrder","prep","prepareMeasureForLine","targetTop","measureCharPrepared","moveVisually","bidi","partPos","mv","getWrappedLineExtent","lineWrapping","wrappedLineExtentChar","wrappedLineExtent","searchInVisualLine","getRes","res","nextCh","getHandlers","emitter","_handlers","noHandlers","detachEvent","signal","handlers","signalDOMEvent","override","preventDefault","defaultPrevented","e_defaultPrevented","codemirrorIgnore","signalCursorActivity","cursorActivity","curOp","cursorActivityHandlers","hasHandler","eventMixin","ctor","e_preventDefault","returnValue","e_stopPropagation","cancelBubble","e_stop","e_target","srcElement","e_button","which","button","mac","ctrlKey","zeroWidthElement","zwspSupported","offsetHeight","offsetWidth","hasBadBidiRects","badBidiRects","txt","r0","range","getBoundingClientRect","r1","right","hasBadZoomedRects","badZoomedRects","normal","fromRange","defineMode","dependencies","modes","defineMIME","mime","spec","mimeModes","resolveMode","getMode","mfactory","modeObj","modeExtensions","exts","helperType","modeProps","prop$1","extendMode","copyState","state","nstate","innerMode","info","startState","a1","a2","highlightLine","forceToEnd","st","modeGen","lineClasses","runMode","loop","overlay","overlays","at","i_end","opaque","classes","bgClass","textClass","getLineStyles","updateFrontier","getStateBefore","maxHighlightLength","stateAfter","styleClasses","frontier","precise","findStartLine","processLine","startAt","StringStream","callBlankLine","eol","readToken","blankLine","inner","token","takeToken","getObj","tokens","extractLineClasses","lineClass","flattenSpans","curStart","curStyle","addModeClass","mName","minindent","minline","lim","indented","updateLine","estimateHeight","estHeight","cleanUpLine","interpretTokenStyle","styleToClassCacheWithMode","styleToClassCache","buildLineContent","lineView","builder","pre","trailingSpace","splitSpaces","getOption","addToken","buildToken","buildTokenBadBidi","allowFrontierUpdate","insertLineContent","maps","caches","lastChild","querySelector","defaultSpecialCharPlaceholder","startStyle","endStyle","displayText","special","specialChars","mustWrap","createDocumentFragment","lastIndex","txt$1","tabWidth","specialCharPlaceholder","fullStyle","trailingBefore","spaceBefore","buildCollapsedSpan","ignoreWidget","widget","needsContentAttribute","setUneditable","allText","spanStyle","spanEndStyle","spanStartStyle","nextChange","foundBookmarks","endStyles","j$1","j$2","upto","tokenText","LineView","hidden","buildViewArray","nextPos","pushOperation","op","operationGroup","ops","ownsGroup","delayedCallbacks","fireCallbacksForOps","group","cursorActivityCalled","finishOperation","endCb","signalLater","orphanDelayedCallbacks","fireOrphanDelayed","delayed","updateLineForChanges","dims","changes","updateLineText","updateLineGutter","updateLineClasses","updateLineWidgets","ensureLineWrapped","replaceChild","updateLineBackground","background","wrap","getLineContent","ext","built","wrapClass","gutter","gutterBackground","gutterClass","fixedGutter","fixedPos","gutterTotalWidth","gutterMarkers","wrap$1","gutterWrap","lineNumber","gutterLeft","gutterWidth","alignable","insertLineWidgets","buildLineElement","insertLineWidgetsFor","allowAbove","widgets","handleMouseEvents","positionLineWidget","above","noHScroll","wrapperWidth","coverGutter","paddingLeft","marginLeft","widgetHeight","parentStyle","clientWidth","eventInWidget","getAttribute","paddingTop","offsetTop","paddingVert","paddingH","getComputedStyle","currentStyle","scrollGap","displayWidth","displayHeight","clientHeight","ensureLineHeights","rect","wrapping","curWidth","heights","rects","getClientRects","bottom","mapFromLineView","before","updateExternalMeasurement","measureChar","bias","findViewForLine","findViewIndex","getDimensions","forceUpdate","hasHeights","prepared","varHeight","measureCharInner","bogus","rtop","rbottom","nodeAndOffsetInLineMap","collapse","mStart","mEnd","coverStart","coverEnd","getUsefulRect","nullRect","maybeUpdateRectForZooming","rSpan","charWidth","rbot","bot","singleCursorHeightPerLine","screen","logicalXDPI","deviceXDPI","scaleX","scaleY","logicalYDPI","deviceYDPI","clearLineMeasurementCacheFor","clearLineMeasurementCache","externalMeasure","clearCaches","pageScrollX","pageXOffset","scrollLeft","pageScrollY","pageYOffset","scrollTop","intoCoordSystem","includeWidgets","yOff","lOff","xOff","fromCoordSystem","coords","localBox","lineSpaceBox","charCoords","cursorCoords","preparedMeasure","getBidi","invert","other","estimateCoords","PosWithInfo","outside","xRel","coordsChar","coordsCharInner","mergedPos","prevDiff","prevPos","beginLeft","box","textHeight","measureText","anchor","clientLeft","offsetLeft","compensateForHScroll","th","perLine","widgetsHeight","estimateLineHeights","est","posFromMouse","liberal","forRect","space","clientX","clientY","colDiff","updateSelection","showSelection","prepareSelection","primary","curFragment","cursors","selFragment","selection","sel","ranges","primIndex","showCursorWhenSelecting","drawSelectionCursor","drawSelectionRange","cursor","cursorHeight","otherCursor","fragment","rightSide","drawForLine","fromArg","toArg","lineLen","rightPos","leftPos","leftSide","padding","sFrom","sTo","fromLine","toLine","singleVLine","leftEnd","rightStart","restartBlink","focused","clearInterval","blinker","visibility","cursorBlinkRate","setInterval","ensureFocus","focus","onFocus","delayBlurEvent","delayingBlurEvent","onBlur","receivedFocus","rmClass","alignHorizontally","comp","gutterW","align","maybeUpdateLineNumberWidth","innerW","updateGutterSpace","updateHeightsInViewport","prevBottom","updateWidgetHeight","visibleLines","viewport","ensure","ensureFrom","ensureTo","setScrollTop","updateDisplaySimple","scrollbars","startWorker","setScrollLeft","isScroller","scrollWidth","wheelEventDelta","dx","wheelDeltaX","dy","wheelDeltaY","detail","axis","HORIZONTAL_AXIS","VERTICAL_AXIS","wheelDelta","wheelEventPixels","delta","wheelPixelsPerUnit","onScrollWheel","scroll","canScrollX","canScrollY","scrollHeight","currentWheelTarget","presto","pixels","wheelSamples","movedX","movedY","sample","measureForScrollbars","docH","viewHeight","viewWidth","barLeft","docHeight","updateScrollbars","startWidth","startHeight","updateScrollbarsInner","sizes","paddingBottom","borderBottom","coverGutterNextToScrollbar","initScrollbars","clear","scrollbarModel","scrollbarStyle","maybeScrollWindow","doScroll","innerHeight","phantom","scrollNode","scrollIntoView","scrollPosIntoView","margin","limit","changed","endCoords","scrollPos","calculateScrollPos","startTop","startLeft","x1","y1","x2","y2","snapMargin","screentop","docBottom","atTop","atBottom","newTop","screenleft","screenw","tooWide","addToScrollPos","resolveScrollToPos","ensureCursorVisible","getCursor","scrollToPos","cursorScrollMargin","isCursor","sPos","scrollTo","startOperation","viewChanged","updateInput","typing","changeObjs","selectionChanged","updateMaxLine","nextOpId","endOperation","endOperations","endOperation_R1","endOperation_W1","endOperation_R2","endOperation_W2","i$4","endOperation_finish","maybeClipScrollbars","mustUpdate","DisplayUpdate","updatedDisplay","updateDisplayIfNeeded","barMeasure","adjustWidthTo","maxScrollLeft","preparedSelection","minWidth","takeFocus","hasFocus","setDocumentHeight","postUpdateDisplay","forceScroll","maybeHiddenMarkers","unhidden","maybeUnhiddenMarkers","finish","runInOp","operation","methodOp","docMethodOp","regChange","lendiff","resetView","cut","viewCuttingPoint","cut$1","cutTop","cutBot","regLineChange","oldN","newN","adjustView","countDirtyView","dirty","highlight","highlightWorker","workTime","changedLines","oldStyles","tooLong","highlighted","oldCls","newCls","ischange","workDelay","marginBottom","borderRightWidth","editorIsHidden","force","visible","viewportMargin","different","wrapperHeight","toUpdate","patchDisplay","minHeight","oldDisplayWidth","updateNumbersFrom","rm","container","updateNumber","updateGutters","specs","gElt","setGuttersForLineNumbers","normalizeSelection","prim","inv","Range","Selection","simpleSelection","changeEnd","adjustForChange","computeSelAfterChange","offsetPos","computeReplacedSel","hint","oldPrev","newPrev","loadMode","modeOption","resetModeState","isWholeLineUpdate","wholeLineUpdateBefore","updateDoc","spansFor","linesFor","Line","firstLine","lastText","lastSpans","nlines","insert","added","added$1","added$2","linkedDocs","sharedHistOnly","propagate","skip","sharedHist","linked","shared","attachDoc","History","startGen","undone","undoDepth","lastModTime","lastSelTime","lastOp","lastSelOp","lastOrigin","lastSelOrigin","generation","maxGeneration","historyChangeFromChange","histChange","attachLocalSpans","clearSelectionEvents","lastChangeEvent","hist","addChangeToHistory","selAfter","opId","history","historyEventDelay","pushSelectionToHistory","selectionEventCanBeMerged","somethingSelected","addSelectionToHistory","clearRedo","dest","equals","existing","removeClearedSpans","explicitlyCleared","getOldSpans","mergeOldSpans","stretched","oldCur","stretchCur","copyHistoryArray","newGroup","instantiateSel","deepCopy","newChanges","extendRange","extend","posBefore","extendSelection","setSelection","extendSelections","heads","newSel","replaceOneSelection","setSimpleSelection","filterSelectionChange","this$1","setSelectionReplaceHistory","setSelectionNoUndo","NaN","setSelectionInner","skipAtomicInSelection","reCheckSelection","sel_dontScroll","mayClear","newAnchor","skipAtomic","newHead","skipAtomicInner","oldPos","atomic","near","movePos","far","cantEdit","selectAll","filterChange","canceled","cancel","makeChange","ignoreReadOnly","suppressEdits","makeChangeInner","makeChangeSingleDoc","rebased","rebaseHist","makeChangeFromHistory","allowSelectionOnly","antiChanges","returned","shiftDoc","distance","removed","makeChangeSingleDocInEditor","recomputeMaxLength","checkWidthStart","changesHandler","changeHandler","replaceRange","splitLines","rebaseHistSelSingle","rebaseHistArray","ok","copied","changeLine","handle","changeType","adjustScrollWhenAboveVisible","addLineWidget","LineWidget","aboveVisible","markText","markTextShared","TextMarker","replacedWith","addToHistory","curLine","clearOnEnter","clearHistory","nextMarkerId","cloneNode","isParent","SharedTextMarker","findSharedMarkers","findMarks","copySharedMarkers","mFrom","mTo","subMark","detachSharedMarkers","subMarker","onDrop","clearDragCursor","lastDrop","files","dataTransfer","isReadOnly","read","loadFile","file","allowDropFileTypes","reader","lineSeparator","readAsText","draggingText","text$1","getData","selected","listSelections","replaceSelection","onDragStart","setData","getSelection","effectAllowed","setDragImage","safari","img","_top","onDragOver","frag","dragCursor","forEachCodeMirror","getElementsByClassName","byClass","ensureGlobalHandlers","globalsRegistered","registerGlobalHandlers","resizeTimer","onResize","setSize","normalizeKeyName","alt","ctrl","cmd","mod","normalizeKeyMap","keymap","keyname","lookupKey","getKeyMap","fallthrough","isModifierKey","keyNames","keyCode","keyName","noShift","altGraphKey","altKey","flipCtrlCmd","metaKey","shiftKey","keyMap","deleteNearSelection","compute","kill","toKill","replaced","lineStart","visual","lineEnd","lineStartSmart","firstNonWS","inWS","doHandleBinding","bound","dropShift","commands","ensurePolled","prevShift","Pass","lookupKeyForEditor","keyMaps","extraKeys","dispatchKey","seq","keySeq","stopSeq","handleKeyBinding","motion","handleCharBinding","onKeyDown","handled","lastStoppedKey","hasCopyEvent","showCrossHair","up","onKeyUp","onKeyPress","onMouseDown","supportsTouch","clickInGutter","selectingText","leftButtonDown","lastMiddleDown","captureRightClick","onContextMenu","lastDoubleClick","lastClick","contained","modifier","dragDrop","dragAndDrop","leftButtonStartDrag","leftButtonSelect","startTime","dragEnd","e2","addNew","extendTo","lastPos","startCol","posCol","startSel","ourIndex","oldRange","ourRange","findWordAt","ranges$1","sel_mouse","curCount","editorSize","move","chromeOS","word","gutterEvent","prevent","mX","mY","lineBox","g","contextMenuInGutter","themeChanged","defineOptions","option","deflt","notOnInit","defaults","optionHandlers","Init","defineOption","lineSep","newBreaks","refresh","getInputField","spellcheck","windows","guttersChanged","detach","attach","wrappingChanged","integer","blur","readOnlyChanged","dragDropChanged","resetPosition","getField","tabIndex","wasOn","funcs","dragFunctions","toggle","enter","over","leave","drop","Doc","inputStyles","inputStyle","pasteIncoming","cutIncoming","Delayed","autofocus","registerEventHandlers","opt","finishInit","initHooks","textRendering","finishTouch","touchFinished","prevTouch","isMouseLikeTouchEvent","touches","touch","radiusX","radiusY","farAway","moved","pageX","pageY","inp","indentLine","how","aggressive","indent","curSpace","curSpaceString","indentUnit","indentString","indentWithTabs","pos$1","setLastCopied","newLastCopied","lastCopied","applyTextInput","inserted","deleted","paste","textLines","splitLinesAuto","multiPaste","lineWise","changeEvent","triggerElectric","handlePaste","pasted","clipboardData","disableInput","electricChars","smartIndent","getModeAt","electricInput","copyableRanges","lineRange","getRange","disableBrowserMagic","field","hiddenTextarea","te","div","ios","border","addEditorMethods","helpers","setOption","getDoc","addKeyMap","removeKeyMap","addOverlay","modeSpec","removeOverlay","indentSelection","newRanges","getTokenAt","getLineTokens","getTokenTypeAt","getHelper","getHelpers","help","_global","getStateAfter","defaultTextHeight","defaultCharWidth","getViewport","addWidget","vert","horiz","vspace","hspace","triggerOnKeyDown","triggerOnKeyPress","triggerOnKeyUp","execCommand","findPosH","amount","unit","hitSide","moveH","extendSelectionsBy","rtlMoveVisually","sel_move","deleteH","findPosV","goalColumn","moveV","goals","headPos","startChar","toggleOverwrite","getScrollInfo","interpret","oldHeight","swapDoc","getWrapperElement","getScrollerElement","getGutterElement","registerHelper","registerGlobalHelper","predicate","findNextLine","moveOnce","boundToLine","origDir","sawType","pageSize","moveAmount","posToDOM","side","badPos","bad","domTextBetween","recognizeMarker","cmText","textContent","markerID","nodeName","closing","nodeValue","domToPos","lineNode","locateNodeInLineView","textNode","topNode","curNode","dist","previousSibling","dist$1","fromTextArea","textarea","tabindex","realSubmit","leaveSubmitMethodAlone","wrappedSubmit","getTextArea","toTextArea","addLegacyProps","cmpPos","platform","ie_upto10","ie_11up","edge","documentMode","qtwebkit","vendor","mac_geMountainLion","presto_version","createRange","endNode","setEnd","setStart","createTextRange","moveToElementText","moveEnd","moveStart","selectInput","select","selectionStart","selectionEnd","charType","lowTypes","arabicTypes","BidiSpan","bidiRE","isNeutral","isStrong","countsAsLeft","countsAsNum","outerType","type$1","prev$1","type$2","type$3","i$5","cur$1","type$4","i$6","end$1","replace$1","i$7","nstart","nl","rt","hasSelection","ownerDocument","parentElement","compareEndPoints","oncopy","lastColumnPos","lastColumnValue","sol","peek","eat","eatWhile","eatSpace","skipToEnd","skipTo","backUp","column","pattern","consume","caseInsensitive","cased","hideFirstChars","NativeScrollbars","checkedZeroWidth","needsH","needsV","sWidth","totalHeight","totalWidth","zeroWidthHack","disableHoriz","enableZeroWidthBar","disableVert","w","pointerEvents","bar","maybeDisable","elementFromPoint","NullScrollbars","native","null","here","there","LeafChunk","removeInner","insertInner","iterN","BranchChunk","remaining","leaf","maybeSpill","me","spilled","sibling","myIndex","used","oldH","withOp","dHeight","nextDocId","cleanGeneration","getLineHandle","getLineNumber","getLineHandleVisualStart","lineCount","setCursor","setSelections","addSelection","getSelections","dup","replaceSelections","undo","redo","undoSelection","redoSelection","setExtending","getExtending","historySize","markClean","changeGeneration","forceSplit","isClean","gen","getHistory","setHistory","histData","setGutterMarker","gutterID","clearGutter","lineInfo","addLineClass","where","removeLineClass","removeLineWidget","setBookmark","realOpts","findMarksAt","getAllMarks","posFromIndex","sepSize","indexFromPos","copyHistory","linkedDoc","unlinkDoc","link","splitIds","iterLinkedDocs","getEditor","eachLine","3","16","17","18","19","20","27","32","33","35","36","37","38","39","40","44","45","46","59","61","91","93","106","107","109","111","127","173","186","187","188","189","190","191","192","219","220","221","222","63232","63233","63234","63235","63272","63273","63275","63276","63277","63302","Left","Right","Up","Down","End","Home","PageUp","PageDown","Delete","Backspace","Shift-Backspace","Tab","Shift-Tab","Enter","Insert","Esc","pcDefault","Ctrl-A","Ctrl-D","Ctrl-Z","Shift-Ctrl-Z","Ctrl-Y","Ctrl-Home","Ctrl-End","Ctrl-Up","Ctrl-Down","Ctrl-Left","Ctrl-Right","Alt-Left","Alt-Right","Ctrl-Backspace","Ctrl-Delete","Ctrl-S","Ctrl-F","Ctrl-G","Shift-Ctrl-G","Shift-Ctrl-F","Shift-Ctrl-R","Ctrl-[","Ctrl-]","Ctrl-U","Shift-Ctrl-U","Alt-U","emacsy","Ctrl-B","Ctrl-P","Ctrl-N","Alt-F","Alt-B","Ctrl-E","Ctrl-V","Shift-Ctrl-V","Ctrl-H","Alt-D","Alt-Backspace","Ctrl-K","Ctrl-T","Ctrl-O","macDefault","Cmd-A","Cmd-D","Cmd-Z","Shift-Cmd-Z","Cmd-Y","Cmd-Home","Cmd-Up","Cmd-End","Cmd-Down","Cmd-Left","Cmd-Right","Ctrl-Alt-Backspace","Alt-Delete","Cmd-S","Cmd-F","Cmd-G","Shift-Cmd-G","Cmd-Alt-F","Shift-Cmd-Alt-F","Cmd-[","Cmd-]","Cmd-Backspace","Cmd-Delete","Cmd-U","Shift-Cmd-U","singleSelection","killLine","deleteLine","delLineLeft","delWrappedLineLeft","delWrappedLineRight","goDocStart","goDocEnd","goLineStart","goLineStartSmart","goLineEnd","goLineRight","goLineLeft","goLineLeftSmart","goLineUp","goLineDown","goPageUp","goPageDown","goCharLeft","goCharRight","goColumnLeft","goColumnRight","goWordLeft","goGroupRight","goGroupLeft","goWordRight","delCharBefore","delCharAfter","delWordBefore","delWordAfter","delGroupBefore","delGroupAfter","indentAuto","indentMore","indentLess","insertTab","insertSoftTab","spaces","defaultTab","transposeChars","newlineAndIndent","sels","openLine","defineInitHook","ContentEditableInput","lastAnchorNode","lastAnchorOffset","lastFocusNode","lastFocusOffset","composing","gracePeriod","readDOMTimeout","onCopyCut","lineWiseCopyCut","clearData","kludge","hadFocus","showPrimarySelection","pollContent","readFromDOMSoon","forceCompositionEnd","showMultipleSelections","curAnchor","anchorNode","anchorOffset","curFocus","focusNode","focusOffset","rangeCount","getRangeAt","rng","removeAllRanges","addRange","startGracePeriod","rememberSelection","selectionInEditor","commonAncestorContainer","pollSelection","pollInterval","fromIndex","fromNode","toNode","toIndex","newText","oldText","cutFront","cutEnd","oldTop","maxCutFront","newBot","oldBot","maxCutEnd","chFrom","chTo","contentEditable","TextareaInput","prevInput","pollingFast","inaccurateSelection","prepareCopyCut","fastPoll","moveInputWithCursor","wrapOff","lineOff","teTop","teLeft","drawn","contextMenuPending","minimal","slowPoll","missed","same","prepareSelectAllHack","extval","rehide","oldWrapperCSS","oldCSS","detectingSelectAll","resetSelectionOnContextMenu","wrapperBox","oldScrollY","scrollY","mouseup","dontDelegate","contenteditable","defineExtension","func","defineDocExtension","593","findMatchingBracket","strict","matching","scanForBracket","forward","maxScanLen","maxScanLineLength","maxScanLines","bracketRegex","autoclear","maxHighlightLen","maxHighlightLineLength","marks","ie_lt8","doMatchBrackets","currentlyHighlighted","(",")","[","]","{","}","594","conf","handler","handleChar","getConfig","closeBrackets","handleBackspace","around","charsAround","handleEnter","explode","contractSelection","inverted","triples","identical","opening","curType","enteringString","isClosingBracket","stringStartsAfter","lastIndexOf","type1","595","expressionAllowed","lastType","parserConfig","readRegexp","escaped","inSet","tp","cont","tokenBase","tokenize","tokenString","tokenComment","isOperatorChar","tokenQuasi","lexical","wordRE","known","keywords","propertyIsEnumerable","jsonldMode","isJsonldKeyword","maybeEnd","findFatArrow","fatArrowAt","arrow","isTS","depth","sawSomething","bracket","brackets","JSLexical","inScope","varname","localVars","cx","vars","parseJS","cc","marked","combinator","jsonMode","expression","statement","pass","register","inList","globalVars","pushcontext","defaultVars","popcontext","pushlex","poplex","expect","wanted","exp","vardef","parenExpr","block","maybeelse","functiondef","forspec","maybelabel","funarg","afterExport","afterImport","typeexpr","expressionInner","expressionNoComma","noComma","arrowBodyNoComma","arrowBody","commasep","maybeop","maybeoperatorNoComma","maybeoperatorComma","atomicTypes","classExpression","maybeexpressionNoComma","maybeexpression","arrayLiteral","contCommasep","objprop","quasi","maybeTarget","expr","continueQuasi","targetNoComma","_","getterSetter","afterprop","what","sep","proceed","maybetype","afterType","typeprop","typearg","maybeReturnType","maybeAssign","vardefCont","proppattern","_type","forspec1","forspec2","formaybeinof","forspec3","classNameAfter","classBody","classfield","maybeFrom","exportField","importSpec","maybeMoreImports","maybeAs","isContinuedStatement","textAfter","statementIndent","jsonld","typescript","wordCharacters","kw","A","B","C","operator","atom","jsKeywords","if","while","with","else","do","try","finally","return","break","continue","new","throw","debugger","var","const","let","catch","for","switch","case","in","typeof","instanceof","true","false","class","super","yield","export","import","extends","await","tsKeywords","interface","implements","enum","public","private","protected","abstract","number","boolean","any","attr","variable","regexp","jsonld-keyword","basecolumn","firstChar","doubleIndentSwitch","blockCommentStart","blockCommentEnd","lineComment","fold","skipExpression","596","597","core_2","logical_operators_const_1","LOGICAL_OPERATORS","addCriteria","removeCriteria","addAction","removeAction","removeActionBtnVisible","598","operators","599","600","963","__webpack_module_template_argument_0__","process","env","DEBUG"],"mappings":"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","file":"4.4.bundle.js","sourcesContent":["webpackJsonp([4],{\n\n/***/ 419:\n/***/ function(module, exports, __webpack_require__) {\n\n\t\"use strict\";\n\tvar __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {\n\t    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;\n\t    if (typeof Reflect === \"object\" && typeof Reflect.decorate === \"function\") r = Reflect.decorate(decorators, target, key, desc);\n\t    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;\n\t    return c > 3 && r && Object.defineProperty(target, key, r), r;\n\t};\n\tvar __metadata = (this && this.__metadata) || function (k, v) {\n\t    if (typeof Reflect === \"object\" && typeof Reflect.metadata === \"function\") return Reflect.metadata(k, v);\n\t};\n\tvar core_1 = __webpack_require__(3);\n\tvar devices_service_1 = __webpack_require__(420);\n\tvar DeviceListResolver = (function () {\n\t    function DeviceListResolver(devicesService) {\n\t        this.devicesService = devicesService;\n\t    }\n\t    DeviceListResolver.prototype.resolve = function () {\n\t        return this.devicesService.getSensors();\n\t    };\n\t    DeviceListResolver = __decorate([\n\t        core_1.Injectable(), \n\t        __metadata('design:paramtypes', [(typeof (_a = typeof devices_service_1.DevicesService !== 'undefined' && devices_service_1.DevicesService) === 'function' && _a) || Object])\n\t    ], DeviceListResolver);\n\t    return DeviceListResolver;\n\t    var _a;\n\t}());\n\texports.DeviceListResolver = DeviceListResolver;\n\n\n/***/ },\n\n/***/ 420:\n/***/ function(module, exports, __webpack_require__) {\n\n\t\"use strict\";\n\tvar __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {\n\t    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;\n\t    if (typeof Reflect === \"object\" && typeof Reflect.decorate === \"function\") r = Reflect.decorate(decorators, target, key, desc);\n\t    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;\n\t    return c > 3 && r && Object.defineProperty(target, key, r), r;\n\t};\n\tvar __metadata = (this && this.__metadata) || function (k, v) {\n\t    if (typeof Reflect === \"object\" && typeof Reflect.metadata === \"function\") return Reflect.metadata(k, v);\n\t};\n\tvar core_1 = __webpack_require__(3);\n\tvar sh_http_service_1 = __webpack_require__(67);\n\tvar DevicesService = (function () {\n\t    function DevicesService(http) {\n\t        this.http = http;\n\t    }\n\t    DevicesService.prototype.getSensors = function () {\n\t        return this.http.get('/sensors');\n\t    };\n\t    DevicesService.prototype.get = function (id) {\n\t        if (id === void 0) { id = ''; }\n\t        return this.http.get(\"/sensors/\" + id);\n\t    };\n\t    DevicesService.prototype.save = function (sensor) {\n\t        return this.http.post('/sensors', sensor);\n\t    };\n\t    DevicesService.prototype.update = function (sensor) {\n\t        return this.http.put(\"/sensors/\" + sensor._id, sensor);\n\t    };\n\t    DevicesService.prototype.delete = function (sensor) {\n\t        return this.http.delete(\"/sensors/\" + sensor._id);\n\t    };\n\t    DevicesService = __decorate([\n\t        core_1.Injectable(), \n\t        __metadata('design:paramtypes', [(typeof (_a = typeof sh_http_service_1.ShHttpService !== 'undefined' && sh_http_service_1.ShHttpService) === 'function' && _a) || Object])\n\t    ], DevicesService);\n\t    return DevicesService;\n\t    var _a;\n\t}());\n\texports.DevicesService = DevicesService;\n\n\n/***/ },\n\n/***/ 434:\n/***/ function(module, exports, __webpack_require__) {\n\n\t\"use strict\";\n\tvar __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {\n\t    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;\n\t    if (typeof Reflect === \"object\" && typeof Reflect.decorate === \"function\") r = Reflect.decorate(decorators, target, key, desc);\n\t    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;\n\t    return c > 3 && r && Object.defineProperty(target, key, r), r;\n\t};\n\tvar __metadata = (this && this.__metadata) || function (k, v) {\n\t    if (typeof Reflect === \"object\" && typeof Reflect.metadata === \"function\") return Reflect.metadata(k, v);\n\t};\n\tvar core_1 = __webpack_require__(3);\n\tvar router_1 = __webpack_require__(29);\n\tvar forms_1 = __webpack_require__(389);\n\tvar shared_module_1 = __webpack_require__(387);\n\tvar device_list_component_1 = __webpack_require__(435);\n\tvar device_component_1 = __webpack_require__(438);\n\tvar device_widget_component_1 = __webpack_require__(442);\n\tvar devices_service_1 = __webpack_require__(420);\n\tvar devices_resolver_1 = __webpack_require__(419);\n\tvar device_widget_service_1 = __webpack_require__(445);\n\tvar servo_widget_component_1 = __webpack_require__(499);\n\tvar switcher_widget_component_1 = __webpack_require__(504);\n\tvar sensor_widget_component_1 = __webpack_require__(507);\n\tvar DevicesModule = (function () {\n\t    function DevicesModule() {\n\t    }\n\t    DevicesModule = __decorate([\n\t        core_1.NgModule({\n\t            id: module.id,\n\t            imports: [\n\t                router_1.RouterModule,\n\t                forms_1.FormsModule,\n\t                shared_module_1.SharedModule\n\t            ],\n\t            declarations: [\n\t                device_widget_component_1.DeviceWidgetComponent,\n\t                sensor_widget_component_1.SensorWidgetComponent,\n\t                switcher_widget_component_1.SwitcherWidgetComponent,\n\t                servo_widget_component_1.ServoWidgetComponent,\n\t                device_list_component_1.DeviceListComponent,\n\t                device_component_1.DeviceComponent\n\t            ],\n\t            exports: [\n\t                device_list_component_1.DeviceListComponent,\n\t                device_component_1.DeviceComponent,\n\t                device_widget_component_1.DeviceWidgetComponent\n\t            ],\n\t            providers: [\n\t                devices_service_1.DevicesService,\n\t                devices_resolver_1.DeviceListResolver,\n\t                device_widget_service_1.DeviceWidgetService\n\t            ]\n\t        }), \n\t        __metadata('design:paramtypes', [])\n\t    ], DevicesModule);\n\t    return DevicesModule;\n\t}());\n\texports.DevicesModule = DevicesModule;\n\n\n/***/ },\n\n/***/ 435:\n/***/ function(module, exports, __webpack_require__) {\n\n\t\"use strict\";\n\tvar __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {\n\t    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;\n\t    if (typeof Reflect === \"object\" && typeof Reflect.decorate === \"function\") r = Reflect.decorate(decorators, target, key, desc);\n\t    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;\n\t    return c > 3 && r && Object.defineProperty(target, key, r), r;\n\t};\n\tvar __metadata = (this && this.__metadata) || function (k, v) {\n\t    if (typeof Reflect === \"object\" && typeof Reflect.metadata === \"function\") return Reflect.metadata(k, v);\n\t};\n\tvar core_1 = __webpack_require__(3);\n\tvar router_1 = __webpack_require__(29);\n\tvar devices_service_1 = __webpack_require__(420);\n\tvar dialog_service_1 = __webpack_require__(398);\n\tvar headersForDisplay = [\n\t    { topic: 'mqttId', name: 'ID', sortable: true },\n\t    { topic: 'type', name: 'Type', sortable: true },\n\t    { topic: 'description', name: 'Description', sortable: true }\n\t];\n\tvar DeviceListComponent = (function () {\n\t    function DeviceListComponent(devicesService, dialogService, viewContainerRef, router) {\n\t        this.devicesService = devicesService;\n\t        this.dialogService = dialogService;\n\t        this.viewContainerRef = viewContainerRef;\n\t        this.router = router;\n\t        this.editOnItemClick = true;\n\t        this.showDeleteButton = true;\n\t        this.statisticLink = '';\n\t        this.sortBy = '';\n\t        this.reverse = false;\n\t        this._headers = [];\n\t        this._headers = headersForDisplay;\n\t    }\n\t    DeviceListComponent.prototype.setSortBy = function (sortByValue) {\n\t        var _this = this;\n\t        this.reverse = this.sortBy === sortByValue ? !this.reverse : false;\n\t        this.sortBy = sortByValue;\n\t        this.deviceList.sort(function (a, b) {\n\t            if (a[sortByValue] < b[sortByValue]) {\n\t                return _this.reverse ? 1 : -1;\n\t            }\n\t            if (a[sortByValue] > b[sortByValue]) {\n\t                return _this.reverse ? -1 : 1;\n\t            }\n\t            return 0;\n\t        });\n\t    };\n\t    DeviceListComponent.prototype.isActive = function (val) {\n\t        return val === this.sortBy;\n\t    };\n\t    DeviceListComponent.prototype.getItemEditLink = function (id) {\n\t        return this.editOnItemClick ? ['./', id] : [];\n\t    };\n\t    DeviceListComponent.prototype.goToDeviceStatistic = function (mqttId, type, $event) {\n\t        $event.stopPropagation();\n\t        this.router.navigate([this.statisticLink, mqttId, 'day', type]);\n\t    };\n\t    DeviceListComponent.prototype.removeSensor = function (item, $event) {\n\t        var _this = this;\n\t        var confirmOptions = {\n\t            title: '',\n\t            message: 'Are you sure you want to delete this device?'\n\t        };\n\t        $event.stopPropagation();\n\t        this.dialogService.confirm(this.viewContainerRef, confirmOptions)\n\t            .filter(function (isConfirmed) { return isConfirmed; })\n\t            .subscribe(function () {\n\t            _this.devicesService\n\t                .delete(item)\n\t                .subscribe(function (data) {\n\t                _this.deviceList = _this.deviceList.filter(function (elem) { return elem._id !== data._id; });\n\t            });\n\t        });\n\t    };\n\t    Object.defineProperty(DeviceListComponent.prototype, \"headers\", {\n\t        get: function () {\n\t            return this._headers;\n\t        },\n\t        enumerable: true,\n\t        configurable: true\n\t    });\n\t    __decorate([\n\t        core_1.Input(), \n\t        __metadata('design:type', Object)\n\t    ], DeviceListComponent.prototype, \"deviceList\", void 0);\n\t    __decorate([\n\t        core_1.Input(), \n\t        __metadata('design:type', Boolean)\n\t    ], DeviceListComponent.prototype, \"editOnItemClick\", void 0);\n\t    __decorate([\n\t        core_1.Input(), \n\t        __metadata('design:type', Boolean)\n\t    ], DeviceListComponent.prototype, \"showDeleteButton\", void 0);\n\t    __decorate([\n\t        core_1.Input(), \n\t        __metadata('design:type', String)\n\t    ], DeviceListComponent.prototype, \"statisticLink\", void 0);\n\t    DeviceListComponent = __decorate([\n\t        core_1.Component({\n\t            selector: 'sh-device-list',\n\t            template: __webpack_require__(436),\n\t            styles: [__webpack_require__(437)]\n\t        }), \n\t        __metadata('design:paramtypes', [(typeof (_a = typeof devices_service_1.DevicesService !== 'undefined' && devices_service_1.DevicesService) === 'function' && _a) || Object, (typeof (_b = typeof dialog_service_1.DialogService !== 'undefined' && dialog_service_1.DialogService) === 'function' && _b) || Object, (typeof (_c = typeof core_1.ViewContainerRef !== 'undefined' && core_1.ViewContainerRef) === 'function' && _c) || Object, (typeof (_d = typeof router_1.Router !== 'undefined' && router_1.Router) === 'function' && _d) || Object])\n\t    ], DeviceListComponent);\n\t    return DeviceListComponent;\n\t    var _a, _b, _c, _d;\n\t}());\n\texports.DeviceListComponent = DeviceListComponent;\n\n\n/***/ },\n\n/***/ 436:\n/***/ function(module, exports) {\n\n\tmodule.exports = \"<div *ngIf=\\\"deviceList.length === 0\\\" class=\\\"empty-list\\\">\\n    <div class=\\\"container empty-list__container\\\">\\n        <div class=\\\"empty-list__container__text\\\">\\n            <h3 class=\\\"empty-list__container__text__main\\\">There are no devices yet</h3>\\n            <h4 class=\\\"empty-list__container__text__additional\\\">Once you connect your device to the system, it will be listed here.</h4>\\n        </div><!-- empty-list__container__text -->\\n    </div><!-- empty-list__container -->\\n</div><!-- empty-list -->\\n\\n<div *ngIf=\\\"deviceList.length !== 0\\\" class=\\\"sensors-list\\\">\\n    <table class=\\\"highlight responsive-table sensors-list-table\\\">\\n        <thead class=\\\"sensors-list-table__head\\\">\\n            <th *ngFor=\\\"let header of headers\\\"\\n                (click)=\\\"setSortBy(header.topic)\\\"\\n                class=\\\"sensors-list-table__head__item\\\"\\n                [class.active]=\\\"isActive(header.topic)\\\"\\n                [class.sortable]=\\\"header.sortable\\\">\\n                {{ header.name }}\\n                <div [class]=\\\"reverse ? 'up' : 'down'\\\"></div>\\n            </th><!-- sensors-list-table__head__item -->\\n        </thead><!-- sensors-list-table__head -->\\n        <tbody class=\\\"sensors-list-table__body\\\">\\n            <tr *ngFor=\\\"let item of deviceList\\\"\\n                [routerLink]=\\\"getItemEditLink(item._id)\\\"\\n                class=\\\"sensors-list-table__body__row\\\">\\n                <td *ngFor=\\\"let header of headers\\\"\\n                    class=\\\"sensors-list-table__body__row__item\\\">\\n                    {{item[header.topic]}}\\n                </td><!-- sensors-list-table__body__row__item -->\\n                <td *ngIf=\\\"statisticLink\\\">\\n                    <div class=\\\"sensor-widget_statistic-button\\\"\\n                        (click)=\\\"goToDeviceStatistic(item.mqttId, item.type, $event)\\\">\\n                    </div>\\n                </td>\\n                <td *ngIf=\\\"showDeleteButton\\\"\\n                    class=\\\"sensors-list-table__body__row__actions\\\">\\n                    <button (click)=\\\"removeSensor(item, $event)\\\"\\n                            class=\\\"waves-effect waves-light btn sensors-list-table__body__row__actions__remove\\\"\\n                            name=\\\"remove-device\\\"\\n                            type=\\\"remove\\\">\\n                        <i class=\\\"material-icons sensors-list-table__body__row__actions__remove__icon\\\">delete</i>\\n                    </button><!-- sensors-list-table__body__row__actions__remove -->\\n                </td><!-- sensors-list-table__body__row__actions -->\\n            </tr><!-- sensors-list-table__body__row -->\\n        </tbody><!-- sensors-list-table__body -->\\n    </table><!-- sensors-list-table -->\\n</div><!-- sensors-list -->\\n\"\n\n/***/ },\n\n/***/ 437:\n/***/ function(module, exports) {\n\n\tmodule.exports = \".sub-header__actions{vertical-align:middle;line-height:54px}.sensors-list-table__head__item.sortable{cursor:pointer}.sensors-list-table__head__item.sortable.active .up{width:0;height:0;border-left:5px solid transparent;border-right:5px solid transparent;border-bottom:5px solid black}.sensors-list-table__head__item.sortable.active .down{width:0;height:0;border-left:5px solid transparent;border-right:5px solid transparent;border-top:5px solid black}.sensors-list-table__body__row__actions__remove{padding:0 15px}.empty-list__container{padding:0px}.empty-list__container::before{content:'';display:block;background:url(\\\"./assets/empty-sensors-list.png\\\") no-repeat;background-size:150px;background-position:calc(100%/2);height:150px;margin:0 6px 0 0}.empty-list__container__text__main{font-family:Roboto-Regular;font-size:24px;text-align:center}.empty-list__container__text__additional{font-family:Roboto-Regular;font-size:15px;text-align:center}.sensor-widget_statistic-button{position:relative;display:block;float:left;cursor:pointer;width:24px;height:26px;margin-top:1px;background-color:#dedede;background-image:url(./assets/statistic.svg)}.sensor-widget_statistic-button:hover{box-shadow:0 2px 4px 0 rgba(0,0,0,0.5)}\\n\"\n\n/***/ },\n\n/***/ 438:\n/***/ function(module, exports, __webpack_require__) {\n\n\t\"use strict\";\n\tvar __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {\n\t    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;\n\t    if (typeof Reflect === \"object\" && typeof Reflect.decorate === \"function\") r = Reflect.decorate(decorators, target, key, desc);\n\t    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;\n\t    return c > 3 && r && Object.defineProperty(target, key, r), r;\n\t};\n\tvar __metadata = (this && this.__metadata) || function (k, v) {\n\t    if (typeof Reflect === \"object\" && typeof Reflect.metadata === \"function\") return Reflect.metadata(k, v);\n\t};\n\tvar core_1 = __webpack_require__(3);\n\tvar device_model_1 = __webpack_require__(439);\n\tvar DeviceComponent = (function () {\n\t    function DeviceComponent() {\n\t        this.switcher = false;\n\t    }\n\t    DeviceComponent.prototype.switchSensor = function () {\n\t        this.device.executor = !this.device.executor;\n\t    };\n\t    DeviceComponent.prototype.switcherImageUrl = function () {\n\t        return this.device.executor ? 'url(assets/switcherON.svg)' : 'url(assets/switcherOFF.svg)';\n\t    };\n\t    __decorate([\n\t        core_1.Input(), \n\t        __metadata('design:type', (typeof (_a = typeof device_model_1.Device !== 'undefined' && device_model_1.Device) === 'function' && _a) || Object)\n\t    ], DeviceComponent.prototype, \"device\", void 0);\n\t    DeviceComponent = __decorate([\n\t        core_1.Component({\n\t            selector: 'sh-device',\n\t            template: __webpack_require__(440),\n\t            styles: [__webpack_require__(441)]\n\t        }), \n\t        __metadata('design:paramtypes', [])\n\t    ], DeviceComponent);\n\t    return DeviceComponent;\n\t    var _a;\n\t}());\n\texports.DeviceComponent = DeviceComponent;\n\n\n/***/ },\n\n/***/ 439:\n/***/ function(module, exports) {\n\n\t\"use strict\";\n\tvar Device = (function () {\n\t    function Device(data) {\n\t        if (data === void 0) { data = {}; }\n\t        Object.assign(this, {\n\t            mqttId: '',\n\t            type: 'servo',\n\t            subType: 'socket',\n\t            description: '',\n\t            executor: false,\n\t            sensor: false\n\t        }, data);\n\t    }\n\t    return Device;\n\t}());\n\texports.Device = Device;\n\n\n/***/ },\n\n/***/ 440:\n/***/ function(module, exports) {\n\n\tmodule.exports = \"<div class=\\\"device\\\">\\n    <div class=\\\"device__icon\\\"\\n         [style.background-image]=\\\"'url(assets/' + device?.subType + '.svg)'\\\">\\n    </div>\\n    <div *ngIf=\\\"device?.type === 'switcher'\\\"\\n         (click)=\\\"switchSensor()\\\">\\n        <div class=\\\"device__switcher\\\"\\n             [style.background-image]=\\\"switcherImageUrl()\\\">\\n        </div>\\n    </div>\\n</div>\\n\"\n\n/***/ },\n\n/***/ 441:\n/***/ function(module, exports) {\n\n\tmodule.exports = \".device{width:42px;height:42px;position:absolute;cursor:move}.device__icon{width:100%;height:100%}.device__switcher{position:absolute;left:42px;top:0;width:42px;height:42px;cursor:pointer}\\n\"\n\n/***/ },\n\n/***/ 442:\n/***/ function(module, exports, __webpack_require__) {\n\n\t\"use strict\";\n\tvar __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {\n\t    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;\n\t    if (typeof Reflect === \"object\" && typeof Reflect.decorate === \"function\") r = Reflect.decorate(decorators, target, key, desc);\n\t    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;\n\t    return c > 3 && r && Object.defineProperty(target, key, r), r;\n\t};\n\tvar __metadata = (this && this.__metadata) || function (k, v) {\n\t    if (typeof Reflect === \"object\" && typeof Reflect.metadata === \"function\") return Reflect.metadata(k, v);\n\t};\n\tvar core_1 = __webpack_require__(3);\n\tvar DeviceWidgetComponent = (function () {\n\t    function DeviceWidgetComponent() {\n\t        this.isEditMode = false;\n\t        this.onRemoveWidget = new core_1.EventEmitter();\n\t    }\n\t    DeviceWidgetComponent.prototype.removeWidget = function () {\n\t        this.onRemoveWidget.emit(this.device);\n\t    };\n\t    __decorate([\n\t        core_1.Input(), \n\t        __metadata('design:type', Object)\n\t    ], DeviceWidgetComponent.prototype, \"device\", void 0);\n\t    __decorate([\n\t        core_1.Input(), \n\t        __metadata('design:type', Boolean)\n\t    ], DeviceWidgetComponent.prototype, \"isEditMode\", void 0);\n\t    __decorate([\n\t        core_1.Output(), \n\t        __metadata('design:type', (typeof (_a = typeof core_1.EventEmitter !== 'undefined' && core_1.EventEmitter) === 'function' && _a) || Object)\n\t    ], DeviceWidgetComponent.prototype, \"onRemoveWidget\", void 0);\n\t    DeviceWidgetComponent = __decorate([\n\t        core_1.Component({\n\t            selector: 'sh-device-widget',\n\t            template: __webpack_require__(443),\n\t            styles: [__webpack_require__(444)]\n\t        }), \n\t        __metadata('design:paramtypes', [])\n\t    ], DeviceWidgetComponent);\n\t    return DeviceWidgetComponent;\n\t    var _a;\n\t}());\n\texports.DeviceWidgetComponent = DeviceWidgetComponent;\n\n\n/***/ },\n\n/***/ 443:\n/***/ function(module, exports) {\n\n\tmodule.exports = \"<div class=\\\"sensor-widget\\\">\\n    <div class=\\\"sensor-widget_header\\\">\\n        <div class=\\\"sensor-widget_button-statistics\\\"\\n             [routerLink]=\\\"['../statistic/sensor-details', device.mqttId, 'day', device.type]\\\">\\n        </div>\\n        <div class=\\\"sensor-widget_header_info\\\">\\n            <span>{{device.description}}</span>\\n        </div>\\n        <button class=\\\"sensor-widget_button-close\\\"\\n                *ngIf=\\\"isEditMode\\\"\\n                (click)=\\\"removeWidget()\\\">\\n        </button>\\n    </div>\\n    <div>\\n        <sh-sensor-widget\\n            [device]=\\\"device\\\"\\n            *ngIf=\\\"!device.executor && !device.servo\\\">\\n        </sh-sensor-widget>\\n        <sh-switcher-widget\\n            [device]=\\\"device\\\"\\n            *ngIf=\\\"device.executor\\\">\\n        </sh-switcher-widget>\\n        <sh-servo-widget\\n            [device]=\\\"device\\\"\\n            *ngIf=\\\"device.servo\\\">\\n        </sh-servo-widget>\\n    </div>\\n</div>\\n\"\n\n/***/ },\n\n/***/ 444:\n/***/ function(module, exports) {\n\n\tmodule.exports = \".sensor-widget{position:relative;width:182px;height:182px;padding:2px;font-family:Roboto;text-align:center;color:white;background-color:#169eb1;border:solid 1px white;overflow:hidden}.sensor-widget_footer,.sensor-widget_header{position:absolute;width:100%;bottom:0;height:27px;max-height:27px;overflow:hidden}.sensor-widget_footer{bottom:0}.sensor-widget_header{top:0;z-index:1}.sensor-widget_button-close,.sensor-widget_button-statistics{position:absolute;top:0;width:27px;height:27px;border:none;box-shadow:none;cursor:pointer;background:transparent;background-repeat:no-repeat;background-position:center;opacity:0.5}.sensor-widget_button-close:hover,.sensor-widget_button-close:active,.sensor-widget_button-close:focus,.sensor-widget_button-statistics:hover,.sensor-widget_button-statistics:active,.sensor-widget_button-statistics:focus{opacity:1}.sensor-widget_button-close{right:0;background-image:url(./assets/close-icon.svg)}.sensor-widget_button-statistics{left:0;background-image:url(./assets/statistics-icon.svg)}.sensor-widget_header_info{line-height:27px;padding:0 27px;overflow:hidden;white-space:nowrap;text-overflow:ellipsis}.sensor-widget_info{margin-top:27px;padding:27px 27px;display:table;height:100%;width:100%}.sensor-widget_info_value{display:table-cell;vertical-align:middle;text-align:center;font-size:24px;line-height:1.5;font-weight:bold;width:100%}.sensor-widget_switcher-info{padding:27px 27px;display:table;height:100%;width:100%}\\n\"\n\n/***/ },\n\n/***/ 445:\n/***/ function(module, exports, __webpack_require__) {\n\n\t\"use strict\";\n\tvar __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {\n\t    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;\n\t    if (typeof Reflect === \"object\" && typeof Reflect.decorate === \"function\") r = Reflect.decorate(decorators, target, key, desc);\n\t    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;\n\t    return c > 3 && r && Object.defineProperty(target, key, r), r;\n\t};\n\tvar __metadata = (this && this.__metadata) || function (k, v) {\n\t    if (typeof Reflect === \"object\" && typeof Reflect.metadata === \"function\") return Reflect.metadata(k, v);\n\t};\n\tvar core_1 = __webpack_require__(3);\n\tvar io = __webpack_require__(446);\n\tvar DeviceWidgetService = (function () {\n\t    function DeviceWidgetService() {\n\t        this.io = io;\n\t        this.setupSocket();\n\t    }\n\t    DeviceWidgetService.prototype.setupSocket = function () {\n\t        this.socket = this.io.connect(({\"backEndUrl\":\"\",\"backEndWebSocketUrl\":\"\"}).backEndWebSocketUrl);\n\t    };\n\t    DeviceWidgetService.prototype.subscribe = function (device, callback) {\n\t        var _this = this;\n\t        if (this.socket.connected) {\n\t            activateDevice.apply(this);\n\t        }\n\t        else {\n\t            this.socket.on('connect', function () {\n\t                activateDevice.apply(_this);\n\t            });\n\t        }\n\t        function activateDevice() {\n\t            this.socket.on('event', callback);\n\t            if (!device) {\n\t                return;\n\t            }\n\t            this.socket.emit('subscribe', { device: device });\n\t        }\n\t    };\n\t    DeviceWidgetService.prototype.unsubscribe = function (device) {\n\t        this.socket.emit('unsubscribe', { device: device });\n\t    };\n\t    DeviceWidgetService.prototype.pushEvent = function (config) {\n\t        this.socket.emit('pushEvent', config);\n\t    };\n\t    DeviceWidgetService = __decorate([\n\t        core_1.Injectable(), \n\t        __metadata('design:paramtypes', [])\n\t    ], DeviceWidgetService);\n\t    return DeviceWidgetService;\n\t}());\n\texports.DeviceWidgetService = DeviceWidgetService;\n\n\n/***/ },\n\n/***/ 446:\n/***/ function(module, exports, __webpack_require__) {\n\n\t\n\t/**\n\t * Module dependencies.\n\t */\n\t\n\tvar url = __webpack_require__(447);\n\tvar parser = __webpack_require__(452);\n\tvar Manager = __webpack_require__(463);\n\tvar debug = __webpack_require__(449)('socket.io-client');\n\t\n\t/**\n\t * Module exports.\n\t */\n\t\n\tmodule.exports = exports = lookup;\n\t\n\t/**\n\t * Managers cache.\n\t */\n\t\n\tvar cache = exports.managers = {};\n\t\n\t/**\n\t * Looks up an existing `Manager` for multiplexing.\n\t * If the user summons:\n\t *\n\t *   `io('http://localhost/a');`\n\t *   `io('http://localhost/b');`\n\t *\n\t * We reuse the existing instance based on same scheme/port/host,\n\t * and we initialize sockets for each namespace.\n\t *\n\t * @api public\n\t */\n\t\n\tfunction lookup (uri, opts) {\n\t  if (typeof uri === 'object') {\n\t    opts = uri;\n\t    uri = undefined;\n\t  }\n\t\n\t  opts = opts || {};\n\t\n\t  var parsed = url(uri);\n\t  var source = parsed.source;\n\t  var id = parsed.id;\n\t  var path = parsed.path;\n\t  var sameNamespace = cache[id] && path in cache[id].nsps;\n\t  var newConnection = opts.forceNew || opts['force new connection'] ||\n\t                      false === opts.multiplex || sameNamespace;\n\t\n\t  var io;\n\t\n\t  if (newConnection) {\n\t    debug('ignoring socket cache for %s', source);\n\t    io = Manager(source, opts);\n\t  } else {\n\t    if (!cache[id]) {\n\t      debug('new io instance for %s', source);\n\t      cache[id] = Manager(source, opts);\n\t    }\n\t    io = cache[id];\n\t  }\n\t  if (parsed.query && !opts.query) {\n\t    opts.query = parsed.query;\n\t  } else if (opts && 'object' === typeof opts.query) {\n\t    opts.query = encodeQueryString(opts.query);\n\t  }\n\t  return io.socket(parsed.path, opts);\n\t}\n\t/**\n\t *  Helper method to parse query objects to string.\n\t * @param {object} query\n\t * @returns {string}\n\t */\n\tfunction encodeQueryString (obj) {\n\t  var str = [];\n\t  for (var p in obj) {\n\t    if (obj.hasOwnProperty(p)) {\n\t      str.push(encodeURIComponent(p) + '=' + encodeURIComponent(obj[p]));\n\t    }\n\t  }\n\t  return str.join('&');\n\t}\n\t/**\n\t * Protocol version.\n\t *\n\t * @api public\n\t */\n\t\n\texports.protocol = parser.protocol;\n\t\n\t/**\n\t * `connect`.\n\t *\n\t * @param {String} uri\n\t * @api public\n\t */\n\t\n\texports.connect = lookup;\n\t\n\t/**\n\t * Expose constructors for standalone build.\n\t *\n\t * @api public\n\t */\n\t\n\texports.Manager = __webpack_require__(463);\n\texports.Socket = __webpack_require__(493);\n\n\n/***/ },\n\n/***/ 447:\n/***/ function(module, exports, __webpack_require__) {\n\n\t/* WEBPACK VAR INJECTION */(function(global) {\n\t/**\n\t * Module dependencies.\n\t */\n\t\n\tvar parseuri = __webpack_require__(448);\n\tvar debug = __webpack_require__(449)('socket.io-client:url');\n\t\n\t/**\n\t * Module exports.\n\t */\n\t\n\tmodule.exports = url;\n\t\n\t/**\n\t * URL parser.\n\t *\n\t * @param {String} url\n\t * @param {Object} An object meant to mimic window.location.\n\t *                 Defaults to window.location.\n\t * @api public\n\t */\n\t\n\tfunction url (uri, loc) {\n\t  var obj = uri;\n\t\n\t  // default to window.location\n\t  loc = loc || global.location;\n\t  if (null == uri) uri = loc.protocol + '//' + loc.host;\n\t\n\t  // relative path support\n\t  if ('string' === typeof uri) {\n\t    if ('/' === uri.charAt(0)) {\n\t      if ('/' === uri.charAt(1)) {\n\t        uri = loc.protocol + uri;\n\t      } else {\n\t        uri = loc.host + uri;\n\t      }\n\t    }\n\t\n\t    if (!/^(https?|wss?):\\/\\//.test(uri)) {\n\t      debug('protocol-less url %s', uri);\n\t      if ('undefined' !== typeof loc) {\n\t        uri = loc.protocol + '//' + uri;\n\t      } else {\n\t        uri = 'https://' + uri;\n\t      }\n\t    }\n\t\n\t    // parse\n\t    debug('parse %s', uri);\n\t    obj = parseuri(uri);\n\t  }\n\t\n\t  // make sure we treat `localhost:80` and `localhost` equally\n\t  if (!obj.port) {\n\t    if (/^(http|ws)$/.test(obj.protocol)) {\n\t      obj.port = '80';\n\t    } else if (/^(http|ws)s$/.test(obj.protocol)) {\n\t      obj.port = '443';\n\t    }\n\t  }\n\t\n\t  obj.path = obj.path || '/';\n\t\n\t  var ipv6 = obj.host.indexOf(':') !== -1;\n\t  var host = ipv6 ? '[' + obj.host + ']' : obj.host;\n\t\n\t  // define unique id\n\t  obj.id = obj.protocol + '://' + host + ':' + obj.port;\n\t  // define href\n\t  obj.href = obj.protocol + '://' + host + (loc && loc.port === obj.port ? '' : (':' + obj.port));\n\t\n\t  return obj;\n\t}\n\t\n\t/* WEBPACK VAR INJECTION */}.call(exports, (function() { return this; }())))\n\n/***/ },\n\n/***/ 448:\n/***/ function(module, exports) {\n\n\t/**\r\n\t * Parses an URI\r\n\t *\r\n\t * @author Steven Levithan <stevenlevithan.com> (MIT license)\r\n\t * @api private\r\n\t */\r\n\t\r\n\tvar re = /^(?:(?![^:@]+:[^:@\\/]*@)(http|https|ws|wss):\\/\\/)?((?:(([^:@]*)(?::([^:@]*))?)?@)?((?:[a-f0-9]{0,4}:){2,7}[a-f0-9]{0,4}|[^:\\/?#]*)(?::(\\d*))?)(((\\/(?:[^?#](?![^?#\\/]*\\.[^?#\\/.]+(?:[?#]|$)))*\\/?)?([^?#\\/]*))(?:\\?([^#]*))?(?:#(.*))?)/;\r\n\t\r\n\tvar parts = [\r\n\t    'source', 'protocol', 'authority', 'userInfo', 'user', 'password', 'host', 'port', 'relative', 'path', 'directory', 'file', 'query', 'anchor'\r\n\t];\r\n\t\r\n\tmodule.exports = function parseuri(str) {\r\n\t    var src = str,\r\n\t        b = str.indexOf('['),\r\n\t        e = str.indexOf(']');\r\n\t\r\n\t    if (b != -1 && e != -1) {\r\n\t        str = str.substring(0, b) + str.substring(b, e).replace(/:/g, ';') + str.substring(e, str.length);\r\n\t    }\r\n\t\r\n\t    var m = re.exec(str || ''),\r\n\t        uri = {},\r\n\t        i = 14;\r\n\t\r\n\t    while (i--) {\r\n\t        uri[parts[i]] = m[i] || '';\r\n\t    }\r\n\t\r\n\t    if (b != -1 && e != -1) {\r\n\t        uri.source = src;\r\n\t        uri.host = uri.host.substring(1, uri.host.length - 1).replace(/;/g, ':');\r\n\t        uri.authority = uri.authority.replace('[', '').replace(']', '').replace(/;/g, ':');\r\n\t        uri.ipv6uri = true;\r\n\t    }\r\n\t\r\n\t    return uri;\r\n\t};\r\n\n\n/***/ },\n\n/***/ 449:\n[963, 450],\n\n/***/ 450:\n/***/ function(module, exports, __webpack_require__) {\n\n\t\n\t/**\n\t * This is the common logic for both the Node.js and web browser\n\t * implementations of `debug()`.\n\t *\n\t * Expose `debug()` as the module.\n\t */\n\t\n\texports = module.exports = debug.debug = debug;\n\texports.coerce = coerce;\n\texports.disable = disable;\n\texports.enable = enable;\n\texports.enabled = enabled;\n\texports.humanize = __webpack_require__(451);\n\t\n\t/**\n\t * The currently active debug mode names, and names to skip.\n\t */\n\t\n\texports.names = [];\n\texports.skips = [];\n\t\n\t/**\n\t * Map of special \"%n\" handling functions, for the debug \"format\" argument.\n\t *\n\t * Valid key names are a single, lowercased letter, i.e. \"n\".\n\t */\n\t\n\texports.formatters = {};\n\t\n\t/**\n\t * Previously assigned color.\n\t */\n\t\n\tvar prevColor = 0;\n\t\n\t/**\n\t * Previous log timestamp.\n\t */\n\t\n\tvar prevTime;\n\t\n\t/**\n\t * Select a color.\n\t *\n\t * @return {Number}\n\t * @api private\n\t */\n\t\n\tfunction selectColor() {\n\t  return exports.colors[prevColor++ % exports.colors.length];\n\t}\n\t\n\t/**\n\t * Create a debugger with the given `namespace`.\n\t *\n\t * @param {String} namespace\n\t * @return {Function}\n\t * @api public\n\t */\n\t\n\tfunction debug(namespace) {\n\t\n\t  // define the `disabled` version\n\t  function disabled() {\n\t  }\n\t  disabled.enabled = false;\n\t\n\t  // define the `enabled` version\n\t  function enabled() {\n\t\n\t    var self = enabled;\n\t\n\t    // set `diff` timestamp\n\t    var curr = +new Date();\n\t    var ms = curr - (prevTime || curr);\n\t    self.diff = ms;\n\t    self.prev = prevTime;\n\t    self.curr = curr;\n\t    prevTime = curr;\n\t\n\t    // add the `color` if not set\n\t    if (null == self.useColors) self.useColors = exports.useColors();\n\t    if (null == self.color && self.useColors) self.color = selectColor();\n\t\n\t    var args = new Array(arguments.length);\n\t    for (var i = 0; i < args.length; i++) {\n\t      args[i] = arguments[i];\n\t    }\n\t\n\t    args[0] = exports.coerce(args[0]);\n\t\n\t    if ('string' !== typeof args[0]) {\n\t      // anything else let's inspect with %o\n\t      args = ['%o'].concat(args);\n\t    }\n\t\n\t    // apply any `formatters` transformations\n\t    var index = 0;\n\t    args[0] = args[0].replace(/%([a-z%])/g, function(match, format) {\n\t      // if we encounter an escaped % then don't increase the array index\n\t      if (match === '%%') return match;\n\t      index++;\n\t      var formatter = exports.formatters[format];\n\t      if ('function' === typeof formatter) {\n\t        var val = args[index];\n\t        match = formatter.call(self, val);\n\t\n\t        // now we need to remove `args[index]` since it's inlined in the `format`\n\t        args.splice(index, 1);\n\t        index--;\n\t      }\n\t      return match;\n\t    });\n\t\n\t    // apply env-specific formatting\n\t    args = exports.formatArgs.apply(self, args);\n\t\n\t    var logFn = enabled.log || exports.log || console.log.bind(console);\n\t    logFn.apply(self, args);\n\t  }\n\t  enabled.enabled = true;\n\t\n\t  var fn = exports.enabled(namespace) ? enabled : disabled;\n\t\n\t  fn.namespace = namespace;\n\t\n\t  return fn;\n\t}\n\t\n\t/**\n\t * Enables a debug mode by namespaces. This can include modes\n\t * separated by a colon and wildcards.\n\t *\n\t * @param {String} namespaces\n\t * @api public\n\t */\n\t\n\tfunction enable(namespaces) {\n\t  exports.save(namespaces);\n\t\n\t  var split = (namespaces || '').split(/[\\s,]+/);\n\t  var len = split.length;\n\t\n\t  for (var i = 0; i < len; i++) {\n\t    if (!split[i]) continue; // ignore empty strings\n\t    namespaces = split[i].replace(/[\\\\^$+?.()|[\\]{}]/g, '\\\\$&').replace(/\\*/g, '.*?');\n\t    if (namespaces[0] === '-') {\n\t      exports.skips.push(new RegExp('^' + namespaces.substr(1) + '$'));\n\t    } else {\n\t      exports.names.push(new RegExp('^' + namespaces + '$'));\n\t    }\n\t  }\n\t}\n\t\n\t/**\n\t * Disable debug output.\n\t *\n\t * @api public\n\t */\n\t\n\tfunction disable() {\n\t  exports.enable('');\n\t}\n\t\n\t/**\n\t * Returns true if the given mode name is enabled, false otherwise.\n\t *\n\t * @param {String} name\n\t * @return {Boolean}\n\t * @api public\n\t */\n\t\n\tfunction enabled(name) {\n\t  var i, len;\n\t  for (i = 0, len = exports.skips.length; i < len; i++) {\n\t    if (exports.skips[i].test(name)) {\n\t      return false;\n\t    }\n\t  }\n\t  for (i = 0, len = exports.names.length; i < len; i++) {\n\t    if (exports.names[i].test(name)) {\n\t      return true;\n\t    }\n\t  }\n\t  return false;\n\t}\n\t\n\t/**\n\t * Coerce `val`.\n\t *\n\t * @param {Mixed} val\n\t * @return {Mixed}\n\t * @api private\n\t */\n\t\n\tfunction coerce(val) {\n\t  if (val instanceof Error) return val.stack || val.message;\n\t  return val;\n\t}\n\n\n/***/ },\n\n/***/ 451:\n/***/ function(module, exports) {\n\n\t/**\n\t * Helpers.\n\t */\n\t\n\tvar s = 1000\n\tvar m = s * 60\n\tvar h = m * 60\n\tvar d = h * 24\n\tvar y = d * 365.25\n\t\n\t/**\n\t * Parse or format the given `val`.\n\t *\n\t * Options:\n\t *\n\t *  - `long` verbose formatting [false]\n\t *\n\t * @param {String|Number} val\n\t * @param {Object} options\n\t * @throws {Error} throw an error if val is not a non-empty string or a number\n\t * @return {String|Number}\n\t * @api public\n\t */\n\t\n\tmodule.exports = function (val, options) {\n\t  options = options || {}\n\t  var type = typeof val\n\t  if (type === 'string' && val.length > 0) {\n\t    return parse(val)\n\t  } else if (type === 'number' && isNaN(val) === false) {\n\t    return options.long ?\n\t\t\t\tfmtLong(val) :\n\t\t\t\tfmtShort(val)\n\t  }\n\t  throw new Error('val is not a non-empty string or a valid number. val=' + JSON.stringify(val))\n\t}\n\t\n\t/**\n\t * Parse the given `str` and return milliseconds.\n\t *\n\t * @param {String} str\n\t * @return {Number}\n\t * @api private\n\t */\n\t\n\tfunction parse(str) {\n\t  str = String(str)\n\t  if (str.length > 10000) {\n\t    return\n\t  }\n\t  var match = /^((?:\\d+)?\\.?\\d+) *(milliseconds?|msecs?|ms|seconds?|secs?|s|minutes?|mins?|m|hours?|hrs?|h|days?|d|years?|yrs?|y)?$/i.exec(str)\n\t  if (!match) {\n\t    return\n\t  }\n\t  var n = parseFloat(match[1])\n\t  var type = (match[2] || 'ms').toLowerCase()\n\t  switch (type) {\n\t    case 'years':\n\t    case 'year':\n\t    case 'yrs':\n\t    case 'yr':\n\t    case 'y':\n\t      return n * y\n\t    case 'days':\n\t    case 'day':\n\t    case 'd':\n\t      return n * d\n\t    case 'hours':\n\t    case 'hour':\n\t    case 'hrs':\n\t    case 'hr':\n\t    case 'h':\n\t      return n * h\n\t    case 'minutes':\n\t    case 'minute':\n\t    case 'mins':\n\t    case 'min':\n\t    case 'm':\n\t      return n * m\n\t    case 'seconds':\n\t    case 'second':\n\t    case 'secs':\n\t    case 'sec':\n\t    case 's':\n\t      return n * s\n\t    case 'milliseconds':\n\t    case 'millisecond':\n\t    case 'msecs':\n\t    case 'msec':\n\t    case 'ms':\n\t      return n\n\t    default:\n\t      return undefined\n\t  }\n\t}\n\t\n\t/**\n\t * Short format for `ms`.\n\t *\n\t * @param {Number} ms\n\t * @return {String}\n\t * @api private\n\t */\n\t\n\tfunction fmtShort(ms) {\n\t  if (ms >= d) {\n\t    return Math.round(ms / d) + 'd'\n\t  }\n\t  if (ms >= h) {\n\t    return Math.round(ms / h) + 'h'\n\t  }\n\t  if (ms >= m) {\n\t    return Math.round(ms / m) + 'm'\n\t  }\n\t  if (ms >= s) {\n\t    return Math.round(ms / s) + 's'\n\t  }\n\t  return ms + 'ms'\n\t}\n\t\n\t/**\n\t * Long format for `ms`.\n\t *\n\t * @param {Number} ms\n\t * @return {String}\n\t * @api private\n\t */\n\t\n\tfunction fmtLong(ms) {\n\t  return plural(ms, d, 'day') ||\n\t    plural(ms, h, 'hour') ||\n\t    plural(ms, m, 'minute') ||\n\t    plural(ms, s, 'second') ||\n\t    ms + ' ms'\n\t}\n\t\n\t/**\n\t * Pluralization helper.\n\t */\n\t\n\tfunction plural(ms, n, name) {\n\t  if (ms < n) {\n\t    return\n\t  }\n\t  if (ms < n * 1.5) {\n\t    return Math.floor(ms / n) + ' ' + name\n\t  }\n\t  return Math.ceil(ms / n) + ' ' + name + 's'\n\t}\n\n\n/***/ },\n\n/***/ 452:\n/***/ function(module, exports, __webpack_require__) {\n\n\t\n\t/**\n\t * Module dependencies.\n\t */\n\t\n\tvar debug = __webpack_require__(453)('socket.io-parser');\n\tvar json = __webpack_require__(456);\n\tvar Emitter = __webpack_require__(459);\n\tvar binary = __webpack_require__(460);\n\tvar isBuf = __webpack_require__(462);\n\t\n\t/**\n\t * Protocol version.\n\t *\n\t * @api public\n\t */\n\t\n\texports.protocol = 4;\n\t\n\t/**\n\t * Packet types.\n\t *\n\t * @api public\n\t */\n\t\n\texports.types = [\n\t  'CONNECT',\n\t  'DISCONNECT',\n\t  'EVENT',\n\t  'ACK',\n\t  'ERROR',\n\t  'BINARY_EVENT',\n\t  'BINARY_ACK'\n\t];\n\t\n\t/**\n\t * Packet type `connect`.\n\t *\n\t * @api public\n\t */\n\t\n\texports.CONNECT = 0;\n\t\n\t/**\n\t * Packet type `disconnect`.\n\t *\n\t * @api public\n\t */\n\t\n\texports.DISCONNECT = 1;\n\t\n\t/**\n\t * Packet type `event`.\n\t *\n\t * @api public\n\t */\n\t\n\texports.EVENT = 2;\n\t\n\t/**\n\t * Packet type `ack`.\n\t *\n\t * @api public\n\t */\n\t\n\texports.ACK = 3;\n\t\n\t/**\n\t * Packet type `error`.\n\t *\n\t * @api public\n\t */\n\t\n\texports.ERROR = 4;\n\t\n\t/**\n\t * Packet type 'binary event'\n\t *\n\t * @api public\n\t */\n\t\n\texports.BINARY_EVENT = 5;\n\t\n\t/**\n\t * Packet type `binary ack`. For acks with binary arguments.\n\t *\n\t * @api public\n\t */\n\t\n\texports.BINARY_ACK = 6;\n\t\n\t/**\n\t * Encoder constructor.\n\t *\n\t * @api public\n\t */\n\t\n\texports.Encoder = Encoder;\n\t\n\t/**\n\t * Decoder constructor.\n\t *\n\t * @api public\n\t */\n\t\n\texports.Decoder = Decoder;\n\t\n\t/**\n\t * A socket.io Encoder instance\n\t *\n\t * @api public\n\t */\n\t\n\tfunction Encoder() {}\n\t\n\t/**\n\t * Encode a packet as a single string if non-binary, or as a\n\t * buffer sequence, depending on packet type.\n\t *\n\t * @param {Object} obj - packet object\n\t * @param {Function} callback - function to handle encodings (likely engine.write)\n\t * @return Calls callback with Array of encodings\n\t * @api public\n\t */\n\t\n\tEncoder.prototype.encode = function(obj, callback){\n\t  debug('encoding packet %j', obj);\n\t\n\t  if (exports.BINARY_EVENT == obj.type || exports.BINARY_ACK == obj.type) {\n\t    encodeAsBinary(obj, callback);\n\t  }\n\t  else {\n\t    var encoding = encodeAsString(obj);\n\t    callback([encoding]);\n\t  }\n\t};\n\t\n\t/**\n\t * Encode packet as string.\n\t *\n\t * @param {Object} packet\n\t * @return {String} encoded\n\t * @api private\n\t */\n\t\n\tfunction encodeAsString(obj) {\n\t  var str = '';\n\t  var nsp = false;\n\t\n\t  // first is type\n\t  str += obj.type;\n\t\n\t  // attachments if we have them\n\t  if (exports.BINARY_EVENT == obj.type || exports.BINARY_ACK == obj.type) {\n\t    str += obj.attachments;\n\t    str += '-';\n\t  }\n\t\n\t  // if we have a namespace other than `/`\n\t  // we append it followed by a comma `,`\n\t  if (obj.nsp && '/' != obj.nsp) {\n\t    nsp = true;\n\t    str += obj.nsp;\n\t  }\n\t\n\t  // immediately followed by the id\n\t  if (null != obj.id) {\n\t    if (nsp) {\n\t      str += ',';\n\t      nsp = false;\n\t    }\n\t    str += obj.id;\n\t  }\n\t\n\t  // json data\n\t  if (null != obj.data) {\n\t    if (nsp) str += ',';\n\t    str += json.stringify(obj.data);\n\t  }\n\t\n\t  debug('encoded %j as %s', obj, str);\n\t  return str;\n\t}\n\t\n\t/**\n\t * Encode packet as 'buffer sequence' by removing blobs, and\n\t * deconstructing packet into object with placeholders and\n\t * a list of buffers.\n\t *\n\t * @param {Object} packet\n\t * @return {Buffer} encoded\n\t * @api private\n\t */\n\t\n\tfunction encodeAsBinary(obj, callback) {\n\t\n\t  function writeEncoding(bloblessData) {\n\t    var deconstruction = binary.deconstructPacket(bloblessData);\n\t    var pack = encodeAsString(deconstruction.packet);\n\t    var buffers = deconstruction.buffers;\n\t\n\t    buffers.unshift(pack); // add packet info to beginning of data list\n\t    callback(buffers); // write all the buffers\n\t  }\n\t\n\t  binary.removeBlobs(obj, writeEncoding);\n\t}\n\t\n\t/**\n\t * A socket.io Decoder instance\n\t *\n\t * @return {Object} decoder\n\t * @api public\n\t */\n\t\n\tfunction Decoder() {\n\t  this.reconstructor = null;\n\t}\n\t\n\t/**\n\t * Mix in `Emitter` with Decoder.\n\t */\n\t\n\tEmitter(Decoder.prototype);\n\t\n\t/**\n\t * Decodes an ecoded packet string into packet JSON.\n\t *\n\t * @param {String} obj - encoded packet\n\t * @return {Object} packet\n\t * @api public\n\t */\n\t\n\tDecoder.prototype.add = function(obj) {\n\t  var packet;\n\t  if ('string' == typeof obj) {\n\t    packet = decodeString(obj);\n\t    if (exports.BINARY_EVENT == packet.type || exports.BINARY_ACK == packet.type) { // binary packet's json\n\t      this.reconstructor = new BinaryReconstructor(packet);\n\t\n\t      // no attachments, labeled binary but no binary data to follow\n\t      if (this.reconstructor.reconPack.attachments === 0) {\n\t        this.emit('decoded', packet);\n\t      }\n\t    } else { // non-binary full packet\n\t      this.emit('decoded', packet);\n\t    }\n\t  }\n\t  else if (isBuf(obj) || obj.base64) { // raw binary data\n\t    if (!this.reconstructor) {\n\t      throw new Error('got binary data when not reconstructing a packet');\n\t    } else {\n\t      packet = this.reconstructor.takeBinaryData(obj);\n\t      if (packet) { // received final buffer\n\t        this.reconstructor = null;\n\t        this.emit('decoded', packet);\n\t      }\n\t    }\n\t  }\n\t  else {\n\t    throw new Error('Unknown type: ' + obj);\n\t  }\n\t};\n\t\n\t/**\n\t * Decode a packet String (JSON data)\n\t *\n\t * @param {String} str\n\t * @return {Object} packet\n\t * @api private\n\t */\n\t\n\tfunction decodeString(str) {\n\t  var p = {};\n\t  var i = 0;\n\t\n\t  // look up type\n\t  p.type = Number(str.charAt(0));\n\t  if (null == exports.types[p.type]) return error();\n\t\n\t  // look up attachments if type binary\n\t  if (exports.BINARY_EVENT == p.type || exports.BINARY_ACK == p.type) {\n\t    var buf = '';\n\t    while (str.charAt(++i) != '-') {\n\t      buf += str.charAt(i);\n\t      if (i == str.length) break;\n\t    }\n\t    if (buf != Number(buf) || str.charAt(i) != '-') {\n\t      throw new Error('Illegal attachments');\n\t    }\n\t    p.attachments = Number(buf);\n\t  }\n\t\n\t  // look up namespace (if any)\n\t  if ('/' == str.charAt(i + 1)) {\n\t    p.nsp = '';\n\t    while (++i) {\n\t      var c = str.charAt(i);\n\t      if (',' == c) break;\n\t      p.nsp += c;\n\t      if (i == str.length) break;\n\t    }\n\t  } else {\n\t    p.nsp = '/';\n\t  }\n\t\n\t  // look up id\n\t  var next = str.charAt(i + 1);\n\t  if ('' !== next && Number(next) == next) {\n\t    p.id = '';\n\t    while (++i) {\n\t      var c = str.charAt(i);\n\t      if (null == c || Number(c) != c) {\n\t        --i;\n\t        break;\n\t      }\n\t      p.id += str.charAt(i);\n\t      if (i == str.length) break;\n\t    }\n\t    p.id = Number(p.id);\n\t  }\n\t\n\t  // look up json data\n\t  if (str.charAt(++i)) {\n\t    p = tryParse(p, str.substr(i));\n\t  }\n\t\n\t  debug('decoded %s as %j', str, p);\n\t  return p;\n\t}\n\t\n\tfunction tryParse(p, str) {\n\t  try {\n\t    p.data = json.parse(str);\n\t  } catch(e){\n\t    return error();\n\t  }\n\t  return p; \n\t};\n\t\n\t/**\n\t * Deallocates a parser's resources\n\t *\n\t * @api public\n\t */\n\t\n\tDecoder.prototype.destroy = function() {\n\t  if (this.reconstructor) {\n\t    this.reconstructor.finishedReconstruction();\n\t  }\n\t};\n\t\n\t/**\n\t * A manager of a binary event's 'buffer sequence'. Should\n\t * be constructed whenever a packet of type BINARY_EVENT is\n\t * decoded.\n\t *\n\t * @param {Object} packet\n\t * @return {BinaryReconstructor} initialized reconstructor\n\t * @api private\n\t */\n\t\n\tfunction BinaryReconstructor(packet) {\n\t  this.reconPack = packet;\n\t  this.buffers = [];\n\t}\n\t\n\t/**\n\t * Method to be called when binary data received from connection\n\t * after a BINARY_EVENT packet.\n\t *\n\t * @param {Buffer | ArrayBuffer} binData - the raw binary data received\n\t * @return {null | Object} returns null if more binary data is expected or\n\t *   a reconstructed packet object if all buffers have been received.\n\t * @api private\n\t */\n\t\n\tBinaryReconstructor.prototype.takeBinaryData = function(binData) {\n\t  this.buffers.push(binData);\n\t  if (this.buffers.length == this.reconPack.attachments) { // done with buffer list\n\t    var packet = binary.reconstructPacket(this.reconPack, this.buffers);\n\t    this.finishedReconstruction();\n\t    return packet;\n\t  }\n\t  return null;\n\t};\n\t\n\t/**\n\t * Cleans up binary packet reconstruction variables.\n\t *\n\t * @api private\n\t */\n\t\n\tBinaryReconstructor.prototype.finishedReconstruction = function() {\n\t  this.reconPack = null;\n\t  this.buffers = [];\n\t};\n\t\n\tfunction error(data){\n\t  return {\n\t    type: exports.ERROR,\n\t    data: 'parser error'\n\t  };\n\t}\n\n\n/***/ },\n\n/***/ 453:\n/***/ function(module, exports, __webpack_require__) {\n\n\t\n\t/**\n\t * This is the web browser implementation of `debug()`.\n\t *\n\t * Expose `debug()` as the module.\n\t */\n\t\n\texports = module.exports = __webpack_require__(454);\n\texports.log = log;\n\texports.formatArgs = formatArgs;\n\texports.save = save;\n\texports.load = load;\n\texports.useColors = useColors;\n\texports.storage = 'undefined' != typeof chrome\n\t               && 'undefined' != typeof chrome.storage\n\t                  ? chrome.storage.local\n\t                  : localstorage();\n\t\n\t/**\n\t * Colors.\n\t */\n\t\n\texports.colors = [\n\t  'lightseagreen',\n\t  'forestgreen',\n\t  'goldenrod',\n\t  'dodgerblue',\n\t  'darkorchid',\n\t  'crimson'\n\t];\n\t\n\t/**\n\t * Currently only WebKit-based Web Inspectors, Firefox >= v31,\n\t * and the Firebug extension (any Firefox version) are known\n\t * to support \"%c\" CSS customizations.\n\t *\n\t * TODO: add a `localStorage` variable to explicitly enable/disable colors\n\t */\n\t\n\tfunction useColors() {\n\t  // is webkit? http://stackoverflow.com/a/16459606/376773\n\t  return ('WebkitAppearance' in document.documentElement.style) ||\n\t    // is firebug? http://stackoverflow.com/a/398120/376773\n\t    (window.console && (console.firebug || (console.exception && console.table))) ||\n\t    // is firefox >= v31?\n\t    // https://developer.mozilla.org/en-US/docs/Tools/Web_Console#Styling_messages\n\t    (navigator.userAgent.toLowerCase().match(/firefox\\/(\\d+)/) && parseInt(RegExp.$1, 10) >= 31);\n\t}\n\t\n\t/**\n\t * Map %j to `JSON.stringify()`, since no Web Inspectors do that by default.\n\t */\n\t\n\texports.formatters.j = function(v) {\n\t  return JSON.stringify(v);\n\t};\n\t\n\t\n\t/**\n\t * Colorize log arguments if enabled.\n\t *\n\t * @api public\n\t */\n\t\n\tfunction formatArgs() {\n\t  var args = arguments;\n\t  var useColors = this.useColors;\n\t\n\t  args[0] = (useColors ? '%c' : '')\n\t    + this.namespace\n\t    + (useColors ? ' %c' : ' ')\n\t    + args[0]\n\t    + (useColors ? '%c ' : ' ')\n\t    + '+' + exports.humanize(this.diff);\n\t\n\t  if (!useColors) return args;\n\t\n\t  var c = 'color: ' + this.color;\n\t  args = [args[0], c, 'color: inherit'].concat(Array.prototype.slice.call(args, 1));\n\t\n\t  // the final \"%c\" is somewhat tricky, because there could be other\n\t  // arguments passed either before or after the %c, so we need to\n\t  // figure out the correct index to insert the CSS into\n\t  var index = 0;\n\t  var lastC = 0;\n\t  args[0].replace(/%[a-z%]/g, function(match) {\n\t    if ('%%' === match) return;\n\t    index++;\n\t    if ('%c' === match) {\n\t      // we only are interested in the *last* %c\n\t      // (the user may have provided their own)\n\t      lastC = index;\n\t    }\n\t  });\n\t\n\t  args.splice(lastC, 0, c);\n\t  return args;\n\t}\n\t\n\t/**\n\t * Invokes `console.log()` when available.\n\t * No-op when `console.log` is not a \"function\".\n\t *\n\t * @api public\n\t */\n\t\n\tfunction log() {\n\t  // this hackery is required for IE8/9, where\n\t  // the `console.log` function doesn't have 'apply'\n\t  return 'object' === typeof console\n\t    && console.log\n\t    && Function.prototype.apply.call(console.log, console, arguments);\n\t}\n\t\n\t/**\n\t * Save `namespaces`.\n\t *\n\t * @param {String} namespaces\n\t * @api private\n\t */\n\t\n\tfunction save(namespaces) {\n\t  try {\n\t    if (null == namespaces) {\n\t      exports.storage.removeItem('debug');\n\t    } else {\n\t      exports.storage.debug = namespaces;\n\t    }\n\t  } catch(e) {}\n\t}\n\t\n\t/**\n\t * Load `namespaces`.\n\t *\n\t * @return {String} returns the previously persisted debug modes\n\t * @api private\n\t */\n\t\n\tfunction load() {\n\t  var r;\n\t  try {\n\t    r = exports.storage.debug;\n\t  } catch(e) {}\n\t  return r;\n\t}\n\t\n\t/**\n\t * Enable namespaces listed in `localStorage.debug` initially.\n\t */\n\t\n\texports.enable(load());\n\t\n\t/**\n\t * Localstorage attempts to return the localstorage.\n\t *\n\t * This is necessary because safari throws\n\t * when a user disables cookies/localstorage\n\t * and you attempt to access it.\n\t *\n\t * @return {LocalStorage}\n\t * @api private\n\t */\n\t\n\tfunction localstorage(){\n\t  try {\n\t    return window.localStorage;\n\t  } catch (e) {}\n\t}\n\n\n/***/ },\n\n/***/ 454:\n/***/ function(module, exports, __webpack_require__) {\n\n\t\n\t/**\n\t * This is the common logic for both the Node.js and web browser\n\t * implementations of `debug()`.\n\t *\n\t * Expose `debug()` as the module.\n\t */\n\t\n\texports = module.exports = debug;\n\texports.coerce = coerce;\n\texports.disable = disable;\n\texports.enable = enable;\n\texports.enabled = enabled;\n\texports.humanize = __webpack_require__(455);\n\t\n\t/**\n\t * The currently active debug mode names, and names to skip.\n\t */\n\t\n\texports.names = [];\n\texports.skips = [];\n\t\n\t/**\n\t * Map of special \"%n\" handling functions, for the debug \"format\" argument.\n\t *\n\t * Valid key names are a single, lowercased letter, i.e. \"n\".\n\t */\n\t\n\texports.formatters = {};\n\t\n\t/**\n\t * Previously assigned color.\n\t */\n\t\n\tvar prevColor = 0;\n\t\n\t/**\n\t * Previous log timestamp.\n\t */\n\t\n\tvar prevTime;\n\t\n\t/**\n\t * Select a color.\n\t *\n\t * @return {Number}\n\t * @api private\n\t */\n\t\n\tfunction selectColor() {\n\t  return exports.colors[prevColor++ % exports.colors.length];\n\t}\n\t\n\t/**\n\t * Create a debugger with the given `namespace`.\n\t *\n\t * @param {String} namespace\n\t * @return {Function}\n\t * @api public\n\t */\n\t\n\tfunction debug(namespace) {\n\t\n\t  // define the `disabled` version\n\t  function disabled() {\n\t  }\n\t  disabled.enabled = false;\n\t\n\t  // define the `enabled` version\n\t  function enabled() {\n\t\n\t    var self = enabled;\n\t\n\t    // set `diff` timestamp\n\t    var curr = +new Date();\n\t    var ms = curr - (prevTime || curr);\n\t    self.diff = ms;\n\t    self.prev = prevTime;\n\t    self.curr = curr;\n\t    prevTime = curr;\n\t\n\t    // add the `color` if not set\n\t    if (null == self.useColors) self.useColors = exports.useColors();\n\t    if (null == self.color && self.useColors) self.color = selectColor();\n\t\n\t    var args = Array.prototype.slice.call(arguments);\n\t\n\t    args[0] = exports.coerce(args[0]);\n\t\n\t    if ('string' !== typeof args[0]) {\n\t      // anything else let's inspect with %o\n\t      args = ['%o'].concat(args);\n\t    }\n\t\n\t    // apply any `formatters` transformations\n\t    var index = 0;\n\t    args[0] = args[0].replace(/%([a-z%])/g, function(match, format) {\n\t      // if we encounter an escaped % then don't increase the array index\n\t      if (match === '%%') return match;\n\t      index++;\n\t      var formatter = exports.formatters[format];\n\t      if ('function' === typeof formatter) {\n\t        var val = args[index];\n\t        match = formatter.call(self, val);\n\t\n\t        // now we need to remove `args[index]` since it's inlined in the `format`\n\t        args.splice(index, 1);\n\t        index--;\n\t      }\n\t      return match;\n\t    });\n\t\n\t    if ('function' === typeof exports.formatArgs) {\n\t      args = exports.formatArgs.apply(self, args);\n\t    }\n\t    var logFn = enabled.log || exports.log || console.log.bind(console);\n\t    logFn.apply(self, args);\n\t  }\n\t  enabled.enabled = true;\n\t\n\t  var fn = exports.enabled(namespace) ? enabled : disabled;\n\t\n\t  fn.namespace = namespace;\n\t\n\t  return fn;\n\t}\n\t\n\t/**\n\t * Enables a debug mode by namespaces. This can include modes\n\t * separated by a colon and wildcards.\n\t *\n\t * @param {String} namespaces\n\t * @api public\n\t */\n\t\n\tfunction enable(namespaces) {\n\t  exports.save(namespaces);\n\t\n\t  var split = (namespaces || '').split(/[\\s,]+/);\n\t  var len = split.length;\n\t\n\t  for (var i = 0; i < len; i++) {\n\t    if (!split[i]) continue; // ignore empty strings\n\t    namespaces = split[i].replace(/\\*/g, '.*?');\n\t    if (namespaces[0] === '-') {\n\t      exports.skips.push(new RegExp('^' + namespaces.substr(1) + '$'));\n\t    } else {\n\t      exports.names.push(new RegExp('^' + namespaces + '$'));\n\t    }\n\t  }\n\t}\n\t\n\t/**\n\t * Disable debug output.\n\t *\n\t * @api public\n\t */\n\t\n\tfunction disable() {\n\t  exports.enable('');\n\t}\n\t\n\t/**\n\t * Returns true if the given mode name is enabled, false otherwise.\n\t *\n\t * @param {String} name\n\t * @return {Boolean}\n\t * @api public\n\t */\n\t\n\tfunction enabled(name) {\n\t  var i, len;\n\t  for (i = 0, len = exports.skips.length; i < len; i++) {\n\t    if (exports.skips[i].test(name)) {\n\t      return false;\n\t    }\n\t  }\n\t  for (i = 0, len = exports.names.length; i < len; i++) {\n\t    if (exports.names[i].test(name)) {\n\t      return true;\n\t    }\n\t  }\n\t  return false;\n\t}\n\t\n\t/**\n\t * Coerce `val`.\n\t *\n\t * @param {Mixed} val\n\t * @return {Mixed}\n\t * @api private\n\t */\n\t\n\tfunction coerce(val) {\n\t  if (val instanceof Error) return val.stack || val.message;\n\t  return val;\n\t}\n\n\n/***/ },\n\n/***/ 455:\n/***/ function(module, exports) {\n\n\t/**\n\t * Helpers.\n\t */\n\t\n\tvar s = 1000;\n\tvar m = s * 60;\n\tvar h = m * 60;\n\tvar d = h * 24;\n\tvar y = d * 365.25;\n\t\n\t/**\n\t * Parse or format the given `val`.\n\t *\n\t * Options:\n\t *\n\t *  - `long` verbose formatting [false]\n\t *\n\t * @param {String|Number} val\n\t * @param {Object} options\n\t * @return {String|Number}\n\t * @api public\n\t */\n\t\n\tmodule.exports = function(val, options){\n\t  options = options || {};\n\t  if ('string' == typeof val) return parse(val);\n\t  return options.long\n\t    ? long(val)\n\t    : short(val);\n\t};\n\t\n\t/**\n\t * Parse the given `str` and return milliseconds.\n\t *\n\t * @param {String} str\n\t * @return {Number}\n\t * @api private\n\t */\n\t\n\tfunction parse(str) {\n\t  str = '' + str;\n\t  if (str.length > 10000) return;\n\t  var match = /^((?:\\d+)?\\.?\\d+) *(milliseconds?|msecs?|ms|seconds?|secs?|s|minutes?|mins?|m|hours?|hrs?|h|days?|d|years?|yrs?|y)?$/i.exec(str);\n\t  if (!match) return;\n\t  var n = parseFloat(match[1]);\n\t  var type = (match[2] || 'ms').toLowerCase();\n\t  switch (type) {\n\t    case 'years':\n\t    case 'year':\n\t    case 'yrs':\n\t    case 'yr':\n\t    case 'y':\n\t      return n * y;\n\t    case 'days':\n\t    case 'day':\n\t    case 'd':\n\t      return n * d;\n\t    case 'hours':\n\t    case 'hour':\n\t    case 'hrs':\n\t    case 'hr':\n\t    case 'h':\n\t      return n * h;\n\t    case 'minutes':\n\t    case 'minute':\n\t    case 'mins':\n\t    case 'min':\n\t    case 'm':\n\t      return n * m;\n\t    case 'seconds':\n\t    case 'second':\n\t    case 'secs':\n\t    case 'sec':\n\t    case 's':\n\t      return n * s;\n\t    case 'milliseconds':\n\t    case 'millisecond':\n\t    case 'msecs':\n\t    case 'msec':\n\t    case 'ms':\n\t      return n;\n\t  }\n\t}\n\t\n\t/**\n\t * Short format for `ms`.\n\t *\n\t * @param {Number} ms\n\t * @return {String}\n\t * @api private\n\t */\n\t\n\tfunction short(ms) {\n\t  if (ms >= d) return Math.round(ms / d) + 'd';\n\t  if (ms >= h) return Math.round(ms / h) + 'h';\n\t  if (ms >= m) return Math.round(ms / m) + 'm';\n\t  if (ms >= s) return Math.round(ms / s) + 's';\n\t  return ms + 'ms';\n\t}\n\t\n\t/**\n\t * Long format for `ms`.\n\t *\n\t * @param {Number} ms\n\t * @return {String}\n\t * @api private\n\t */\n\t\n\tfunction long(ms) {\n\t  return plural(ms, d, 'day')\n\t    || plural(ms, h, 'hour')\n\t    || plural(ms, m, 'minute')\n\t    || plural(ms, s, 'second')\n\t    || ms + ' ms';\n\t}\n\t\n\t/**\n\t * Pluralization helper.\n\t */\n\t\n\tfunction plural(ms, n, name) {\n\t  if (ms < n) return;\n\t  if (ms < n * 1.5) return Math.floor(ms / n) + ' ' + name;\n\t  return Math.ceil(ms / n) + ' ' + name + 's';\n\t}\n\n\n/***/ },\n\n/***/ 456:\n/***/ function(module, exports, __webpack_require__) {\n\n\tvar __WEBPACK_AMD_DEFINE_RESULT__;/* WEBPACK VAR INJECTION */(function(module, global) {/*! JSON v3.3.2 | http://bestiejs.github.io/json3 | Copyright 2012-2014, Kit Cambridge | http://kit.mit-license.org */\n\t;(function () {\n\t  // Detect the `define` function exposed by asynchronous module loaders. The\n\t  // strict `define` check is necessary for compatibility with `r.js`.\n\t  var isLoader = \"function\" === \"function\" && __webpack_require__(458);\n\t\n\t  // A set of types used to distinguish objects from primitives.\n\t  var objectTypes = {\n\t    \"function\": true,\n\t    \"object\": true\n\t  };\n\t\n\t  // Detect the `exports` object exposed by CommonJS implementations.\n\t  var freeExports = objectTypes[typeof exports] && exports && !exports.nodeType && exports;\n\t\n\t  // Use the `global` object exposed by Node (including Browserify via\n\t  // `insert-module-globals`), Narwhal, and Ringo as the default context,\n\t  // and the `window` object in browsers. Rhino exports a `global` function\n\t  // instead.\n\t  var root = objectTypes[typeof window] && window || this,\n\t      freeGlobal = freeExports && objectTypes[typeof module] && module && !module.nodeType && typeof global == \"object\" && global;\n\t\n\t  if (freeGlobal && (freeGlobal[\"global\"] === freeGlobal || freeGlobal[\"window\"] === freeGlobal || freeGlobal[\"self\"] === freeGlobal)) {\n\t    root = freeGlobal;\n\t  }\n\t\n\t  // Public: Initializes JSON 3 using the given `context` object, attaching the\n\t  // `stringify` and `parse` functions to the specified `exports` object.\n\t  function runInContext(context, exports) {\n\t    context || (context = root[\"Object\"]());\n\t    exports || (exports = root[\"Object\"]());\n\t\n\t    // Native constructor aliases.\n\t    var Number = context[\"Number\"] || root[\"Number\"],\n\t        String = context[\"String\"] || root[\"String\"],\n\t        Object = context[\"Object\"] || root[\"Object\"],\n\t        Date = context[\"Date\"] || root[\"Date\"],\n\t        SyntaxError = context[\"SyntaxError\"] || root[\"SyntaxError\"],\n\t        TypeError = context[\"TypeError\"] || root[\"TypeError\"],\n\t        Math = context[\"Math\"] || root[\"Math\"],\n\t        nativeJSON = context[\"JSON\"] || root[\"JSON\"];\n\t\n\t    // Delegate to the native `stringify` and `parse` implementations.\n\t    if (typeof nativeJSON == \"object\" && nativeJSON) {\n\t      exports.stringify = nativeJSON.stringify;\n\t      exports.parse = nativeJSON.parse;\n\t    }\n\t\n\t    // Convenience aliases.\n\t    var objectProto = Object.prototype,\n\t        getClass = objectProto.toString,\n\t        isProperty, forEach, undef;\n\t\n\t    // Test the `Date#getUTC*` methods. Based on work by @Yaffle.\n\t    var isExtended = new Date(-3509827334573292);\n\t    try {\n\t      // The `getUTCFullYear`, `Month`, and `Date` methods return nonsensical\n\t      // results for certain dates in Opera >= 10.53.\n\t      isExtended = isExtended.getUTCFullYear() == -109252 && isExtended.getUTCMonth() === 0 && isExtended.getUTCDate() === 1 &&\n\t        // Safari < 2.0.2 stores the internal millisecond time value correctly,\n\t        // but clips the values returned by the date methods to the range of\n\t        // signed 32-bit integers ([-2 ** 31, 2 ** 31 - 1]).\n\t        isExtended.getUTCHours() == 10 && isExtended.getUTCMinutes() == 37 && isExtended.getUTCSeconds() == 6 && isExtended.getUTCMilliseconds() == 708;\n\t    } catch (exception) {}\n\t\n\t    // Internal: Determines whether the native `JSON.stringify` and `parse`\n\t    // implementations are spec-compliant. Based on work by Ken Snyder.\n\t    function has(name) {\n\t      if (has[name] !== undef) {\n\t        // Return cached feature test result.\n\t        return has[name];\n\t      }\n\t      var isSupported;\n\t      if (name == \"bug-string-char-index\") {\n\t        // IE <= 7 doesn't support accessing string characters using square\n\t        // bracket notation. IE 8 only supports this for primitives.\n\t        isSupported = \"a\"[0] != \"a\";\n\t      } else if (name == \"json\") {\n\t        // Indicates whether both `JSON.stringify` and `JSON.parse` are\n\t        // supported.\n\t        isSupported = has(\"json-stringify\") && has(\"json-parse\");\n\t      } else {\n\t        var value, serialized = '{\"a\":[1,true,false,null,\"\\\\u0000\\\\b\\\\n\\\\f\\\\r\\\\t\"]}';\n\t        // Test `JSON.stringify`.\n\t        if (name == \"json-stringify\") {\n\t          var stringify = exports.stringify, stringifySupported = typeof stringify == \"function\" && isExtended;\n\t          if (stringifySupported) {\n\t            // A test function object with a custom `toJSON` method.\n\t            (value = function () {\n\t              return 1;\n\t            }).toJSON = value;\n\t            try {\n\t              stringifySupported =\n\t                // Firefox 3.1b1 and b2 serialize string, number, and boolean\n\t                // primitives as object literals.\n\t                stringify(0) === \"0\" &&\n\t                // FF 3.1b1, b2, and JSON 2 serialize wrapped primitives as object\n\t                // literals.\n\t                stringify(new Number()) === \"0\" &&\n\t                stringify(new String()) == '\"\"' &&\n\t                // FF 3.1b1, 2 throw an error if the value is `null`, `undefined`, or\n\t                // does not define a canonical JSON representation (this applies to\n\t                // objects with `toJSON` properties as well, *unless* they are nested\n\t                // within an object or array).\n\t                stringify(getClass) === undef &&\n\t                // IE 8 serializes `undefined` as `\"undefined\"`. Safari <= 5.1.7 and\n\t                // FF 3.1b3 pass this test.\n\t                stringify(undef) === undef &&\n\t                // Safari <= 5.1.7 and FF 3.1b3 throw `Error`s and `TypeError`s,\n\t                // respectively, if the value is omitted entirely.\n\t                stringify() === undef &&\n\t                // FF 3.1b1, 2 throw an error if the given value is not a number,\n\t                // string, array, object, Boolean, or `null` literal. This applies to\n\t                // objects with custom `toJSON` methods as well, unless they are nested\n\t                // inside object or array literals. YUI 3.0.0b1 ignores custom `toJSON`\n\t                // methods entirely.\n\t                stringify(value) === \"1\" &&\n\t                stringify([value]) == \"[1]\" &&\n\t                // Prototype <= 1.6.1 serializes `[undefined]` as `\"[]\"` instead of\n\t                // `\"[null]\"`.\n\t                stringify([undef]) == \"[null]\" &&\n\t                // YUI 3.0.0b1 fails to serialize `null` literals.\n\t                stringify(null) == \"null\" &&\n\t                // FF 3.1b1, 2 halts serialization if an array contains a function:\n\t                // `[1, true, getClass, 1]` serializes as \"[1,true,],\". FF 3.1b3\n\t                // elides non-JSON values from objects and arrays, unless they\n\t                // define custom `toJSON` methods.\n\t                stringify([undef, getClass, null]) == \"[null,null,null]\" &&\n\t                // Simple serialization test. FF 3.1b1 uses Unicode escape sequences\n\t                // where character escape codes are expected (e.g., `\\b` => `\\u0008`).\n\t                stringify({ \"a\": [value, true, false, null, \"\\x00\\b\\n\\f\\r\\t\"] }) == serialized &&\n\t                // FF 3.1b1 and b2 ignore the `filter` and `width` arguments.\n\t                stringify(null, value) === \"1\" &&\n\t                stringify([1, 2], null, 1) == \"[\\n 1,\\n 2\\n]\" &&\n\t                // JSON 2, Prototype <= 1.7, and older WebKit builds incorrectly\n\t                // serialize extended years.\n\t                stringify(new Date(-8.64e15)) == '\"-271821-04-20T00:00:00.000Z\"' &&\n\t                // The milliseconds are optional in ES 5, but required in 5.1.\n\t                stringify(new Date(8.64e15)) == '\"+275760-09-13T00:00:00.000Z\"' &&\n\t                // Firefox <= 11.0 incorrectly serializes years prior to 0 as negative\n\t                // four-digit years instead of six-digit years. Credits: @Yaffle.\n\t                stringify(new Date(-621987552e5)) == '\"-000001-01-01T00:00:00.000Z\"' &&\n\t                // Safari <= 5.1.5 and Opera >= 10.53 incorrectly serialize millisecond\n\t                // values less than 1000. Credits: @Yaffle.\n\t                stringify(new Date(-1)) == '\"1969-12-31T23:59:59.999Z\"';\n\t            } catch (exception) {\n\t              stringifySupported = false;\n\t            }\n\t          }\n\t          isSupported = stringifySupported;\n\t        }\n\t        // Test `JSON.parse`.\n\t        if (name == \"json-parse\") {\n\t          var parse = exports.parse;\n\t          if (typeof parse == \"function\") {\n\t            try {\n\t              // FF 3.1b1, b2 will throw an exception if a bare literal is provided.\n\t              // Conforming implementations should also coerce the initial argument to\n\t              // a string prior to parsing.\n\t              if (parse(\"0\") === 0 && !parse(false)) {\n\t                // Simple parsing test.\n\t                value = parse(serialized);\n\t                var parseSupported = value[\"a\"].length == 5 && value[\"a\"][0] === 1;\n\t                if (parseSupported) {\n\t                  try {\n\t                    // Safari <= 5.1.2 and FF 3.1b1 allow unescaped tabs in strings.\n\t                    parseSupported = !parse('\"\\t\"');\n\t                  } catch (exception) {}\n\t                  if (parseSupported) {\n\t                    try {\n\t                      // FF 4.0 and 4.0.1 allow leading `+` signs and leading\n\t                      // decimal points. FF 4.0, 4.0.1, and IE 9-10 also allow\n\t                      // certain octal literals.\n\t                      parseSupported = parse(\"01\") !== 1;\n\t                    } catch (exception) {}\n\t                  }\n\t                  if (parseSupported) {\n\t                    try {\n\t                      // FF 4.0, 4.0.1, and Rhino 1.7R3-R4 allow trailing decimal\n\t                      // points. These environments, along with FF 3.1b1 and 2,\n\t                      // also allow trailing commas in JSON objects and arrays.\n\t                      parseSupported = parse(\"1.\") !== 1;\n\t                    } catch (exception) {}\n\t                  }\n\t                }\n\t              }\n\t            } catch (exception) {\n\t              parseSupported = false;\n\t            }\n\t          }\n\t          isSupported = parseSupported;\n\t        }\n\t      }\n\t      return has[name] = !!isSupported;\n\t    }\n\t\n\t    if (!has(\"json\")) {\n\t      // Common `[[Class]]` name aliases.\n\t      var functionClass = \"[object Function]\",\n\t          dateClass = \"[object Date]\",\n\t          numberClass = \"[object Number]\",\n\t          stringClass = \"[object String]\",\n\t          arrayClass = \"[object Array]\",\n\t          booleanClass = \"[object Boolean]\";\n\t\n\t      // Detect incomplete support for accessing string characters by index.\n\t      var charIndexBuggy = has(\"bug-string-char-index\");\n\t\n\t      // Define additional utility methods if the `Date` methods are buggy.\n\t      if (!isExtended) {\n\t        var floor = Math.floor;\n\t        // A mapping between the months of the year and the number of days between\n\t        // January 1st and the first of the respective month.\n\t        var Months = [0, 31, 59, 90, 120, 151, 181, 212, 243, 273, 304, 334];\n\t        // Internal: Calculates the number of days between the Unix epoch and the\n\t        // first day of the given month.\n\t        var getDay = function (year, month) {\n\t          return Months[month] + 365 * (year - 1970) + floor((year - 1969 + (month = +(month > 1))) / 4) - floor((year - 1901 + month) / 100) + floor((year - 1601 + month) / 400);\n\t        };\n\t      }\n\t\n\t      // Internal: Determines if a property is a direct property of the given\n\t      // object. Delegates to the native `Object#hasOwnProperty` method.\n\t      if (!(isProperty = objectProto.hasOwnProperty)) {\n\t        isProperty = function (property) {\n\t          var members = {}, constructor;\n\t          if ((members.__proto__ = null, members.__proto__ = {\n\t            // The *proto* property cannot be set multiple times in recent\n\t            // versions of Firefox and SeaMonkey.\n\t            \"toString\": 1\n\t          }, members).toString != getClass) {\n\t            // Safari <= 2.0.3 doesn't implement `Object#hasOwnProperty`, but\n\t            // supports the mutable *proto* property.\n\t            isProperty = function (property) {\n\t              // Capture and break the object's prototype chain (see section 8.6.2\n\t              // of the ES 5.1 spec). The parenthesized expression prevents an\n\t              // unsafe transformation by the Closure Compiler.\n\t              var original = this.__proto__, result = property in (this.__proto__ = null, this);\n\t              // Restore the original prototype chain.\n\t              this.__proto__ = original;\n\t              return result;\n\t            };\n\t          } else {\n\t            // Capture a reference to the top-level `Object` constructor.\n\t            constructor = members.constructor;\n\t            // Use the `constructor` property to simulate `Object#hasOwnProperty` in\n\t            // other environments.\n\t            isProperty = function (property) {\n\t              var parent = (this.constructor || constructor).prototype;\n\t              return property in this && !(property in parent && this[property] === parent[property]);\n\t            };\n\t          }\n\t          members = null;\n\t          return isProperty.call(this, property);\n\t        };\n\t      }\n\t\n\t      // Internal: Normalizes the `for...in` iteration algorithm across\n\t      // environments. Each enumerated key is yielded to a `callback` function.\n\t      forEach = function (object, callback) {\n\t        var size = 0, Properties, members, property;\n\t\n\t        // Tests for bugs in the current environment's `for...in` algorithm. The\n\t        // `valueOf` property inherits the non-enumerable flag from\n\t        // `Object.prototype` in older versions of IE, Netscape, and Mozilla.\n\t        (Properties = function () {\n\t          this.valueOf = 0;\n\t        }).prototype.valueOf = 0;\n\t\n\t        // Iterate over a new instance of the `Properties` class.\n\t        members = new Properties();\n\t        for (property in members) {\n\t          // Ignore all properties inherited from `Object.prototype`.\n\t          if (isProperty.call(members, property)) {\n\t            size++;\n\t          }\n\t        }\n\t        Properties = members = null;\n\t\n\t        // Normalize the iteration algorithm.\n\t        if (!size) {\n\t          // A list of non-enumerable properties inherited from `Object.prototype`.\n\t          members = [\"valueOf\", \"toString\", \"toLocaleString\", \"propertyIsEnumerable\", \"isPrototypeOf\", \"hasOwnProperty\", \"constructor\"];\n\t          // IE <= 8, Mozilla 1.0, and Netscape 6.2 ignore shadowed non-enumerable\n\t          // properties.\n\t          forEach = function (object, callback) {\n\t            var isFunction = getClass.call(object) == functionClass, property, length;\n\t            var hasProperty = !isFunction && typeof object.constructor != \"function\" && objectTypes[typeof object.hasOwnProperty] && object.hasOwnProperty || isProperty;\n\t            for (property in object) {\n\t              // Gecko <= 1.0 enumerates the `prototype` property of functions under\n\t              // certain conditions; IE does not.\n\t              if (!(isFunction && property == \"prototype\") && hasProperty.call(object, property)) {\n\t                callback(property);\n\t              }\n\t            }\n\t            // Manually invoke the callback for each non-enumerable property.\n\t            for (length = members.length; property = members[--length]; hasProperty.call(object, property) && callback(property));\n\t          };\n\t        } else if (size == 2) {\n\t          // Safari <= 2.0.4 enumerates shadowed properties twice.\n\t          forEach = function (object, callback) {\n\t            // Create a set of iterated properties.\n\t            var members = {}, isFunction = getClass.call(object) == functionClass, property;\n\t            for (property in object) {\n\t              // Store each property name to prevent double enumeration. The\n\t              // `prototype` property of functions is not enumerated due to cross-\n\t              // environment inconsistencies.\n\t              if (!(isFunction && property == \"prototype\") && !isProperty.call(members, property) && (members[property] = 1) && isProperty.call(object, property)) {\n\t                callback(property);\n\t              }\n\t            }\n\t          };\n\t        } else {\n\t          // No bugs detected; use the standard `for...in` algorithm.\n\t          forEach = function (object, callback) {\n\t            var isFunction = getClass.call(object) == functionClass, property, isConstructor;\n\t            for (property in object) {\n\t              if (!(isFunction && property == \"prototype\") && isProperty.call(object, property) && !(isConstructor = property === \"constructor\")) {\n\t                callback(property);\n\t              }\n\t            }\n\t            // Manually invoke the callback for the `constructor` property due to\n\t            // cross-environment inconsistencies.\n\t            if (isConstructor || isProperty.call(object, (property = \"constructor\"))) {\n\t              callback(property);\n\t            }\n\t          };\n\t        }\n\t        return forEach(object, callback);\n\t      };\n\t\n\t      // Public: Serializes a JavaScript `value` as a JSON string. The optional\n\t      // `filter` argument may specify either a function that alters how object and\n\t      // array members are serialized, or an array of strings and numbers that\n\t      // indicates which properties should be serialized. The optional `width`\n\t      // argument may be either a string or number that specifies the indentation\n\t      // level of the output.\n\t      if (!has(\"json-stringify\")) {\n\t        // Internal: A map of control characters and their escaped equivalents.\n\t        var Escapes = {\n\t          92: \"\\\\\\\\\",\n\t          34: '\\\\\"',\n\t          8: \"\\\\b\",\n\t          12: \"\\\\f\",\n\t          10: \"\\\\n\",\n\t          13: \"\\\\r\",\n\t          9: \"\\\\t\"\n\t        };\n\t\n\t        // Internal: Converts `value` into a zero-padded string such that its\n\t        // length is at least equal to `width`. The `width` must be <= 6.\n\t        var leadingZeroes = \"000000\";\n\t        var toPaddedString = function (width, value) {\n\t          // The `|| 0` expression is necessary to work around a bug in\n\t          // Opera <= 7.54u2 where `0 == -0`, but `String(-0) !== \"0\"`.\n\t          return (leadingZeroes + (value || 0)).slice(-width);\n\t        };\n\t\n\t        // Internal: Double-quotes a string `value`, replacing all ASCII control\n\t        // characters (characters with code unit values between 0 and 31) with\n\t        // their escaped equivalents. This is an implementation of the\n\t        // `Quote(value)` operation defined in ES 5.1 section 15.12.3.\n\t        var unicodePrefix = \"\\\\u00\";\n\t        var quote = function (value) {\n\t          var result = '\"', index = 0, length = value.length, useCharIndex = !charIndexBuggy || length > 10;\n\t          var symbols = useCharIndex && (charIndexBuggy ? value.split(\"\") : value);\n\t          for (; index < length; index++) {\n\t            var charCode = value.charCodeAt(index);\n\t            // If the character is a control character, append its Unicode or\n\t            // shorthand escape sequence; otherwise, append the character as-is.\n\t            switch (charCode) {\n\t              case 8: case 9: case 10: case 12: case 13: case 34: case 92:\n\t                result += Escapes[charCode];\n\t                break;\n\t              default:\n\t                if (charCode < 32) {\n\t                  result += unicodePrefix + toPaddedString(2, charCode.toString(16));\n\t                  break;\n\t                }\n\t                result += useCharIndex ? symbols[index] : value.charAt(index);\n\t            }\n\t          }\n\t          return result + '\"';\n\t        };\n\t\n\t        // Internal: Recursively serializes an object. Implements the\n\t        // `Str(key, holder)`, `JO(value)`, and `JA(value)` operations.\n\t        var serialize = function (property, object, callback, properties, whitespace, indentation, stack) {\n\t          var value, className, year, month, date, time, hours, minutes, seconds, milliseconds, results, element, index, length, prefix, result;\n\t          try {\n\t            // Necessary for host object support.\n\t            value = object[property];\n\t          } catch (exception) {}\n\t          if (typeof value == \"object\" && value) {\n\t            className = getClass.call(value);\n\t            if (className == dateClass && !isProperty.call(value, \"toJSON\")) {\n\t              if (value > -1 / 0 && value < 1 / 0) {\n\t                // Dates are serialized according to the `Date#toJSON` method\n\t                // specified in ES 5.1 section 15.9.5.44. See section 15.9.1.15\n\t                // for the ISO 8601 date time string format.\n\t                if (getDay) {\n\t                  // Manually compute the year, month, date, hours, minutes,\n\t                  // seconds, and milliseconds if the `getUTC*` methods are\n\t                  // buggy. Adapted from @Yaffle's `date-shim` project.\n\t                  date = floor(value / 864e5);\n\t                  for (year = floor(date / 365.2425) + 1970 - 1; getDay(year + 1, 0) <= date; year++);\n\t                  for (month = floor((date - getDay(year, 0)) / 30.42); getDay(year, month + 1) <= date; month++);\n\t                  date = 1 + date - getDay(year, month);\n\t                  // The `time` value specifies the time within the day (see ES\n\t                  // 5.1 section 15.9.1.2). The formula `(A % B + B) % B` is used\n\t                  // to compute `A modulo B`, as the `%` operator does not\n\t                  // correspond to the `modulo` operation for negative numbers.\n\t                  time = (value % 864e5 + 864e5) % 864e5;\n\t                  // The hours, minutes, seconds, and milliseconds are obtained by\n\t                  // decomposing the time within the day. See section 15.9.1.10.\n\t                  hours = floor(time / 36e5) % 24;\n\t                  minutes = floor(time / 6e4) % 60;\n\t                  seconds = floor(time / 1e3) % 60;\n\t                  milliseconds = time % 1e3;\n\t                } else {\n\t                  year = value.getUTCFullYear();\n\t                  month = value.getUTCMonth();\n\t                  date = value.getUTCDate();\n\t                  hours = value.getUTCHours();\n\t                  minutes = value.getUTCMinutes();\n\t                  seconds = value.getUTCSeconds();\n\t                  milliseconds = value.getUTCMilliseconds();\n\t                }\n\t                // Serialize extended years correctly.\n\t                value = (year <= 0 || year >= 1e4 ? (year < 0 ? \"-\" : \"+\") + toPaddedString(6, year < 0 ? -year : year) : toPaddedString(4, year)) +\n\t                  \"-\" + toPaddedString(2, month + 1) + \"-\" + toPaddedString(2, date) +\n\t                  // Months, dates, hours, minutes, and seconds should have two\n\t                  // digits; milliseconds should have three.\n\t                  \"T\" + toPaddedString(2, hours) + \":\" + toPaddedString(2, minutes) + \":\" + toPaddedString(2, seconds) +\n\t                  // Milliseconds are optional in ES 5.0, but required in 5.1.\n\t                  \".\" + toPaddedString(3, milliseconds) + \"Z\";\n\t              } else {\n\t                value = null;\n\t              }\n\t            } else if (typeof value.toJSON == \"function\" && ((className != numberClass && className != stringClass && className != arrayClass) || isProperty.call(value, \"toJSON\"))) {\n\t              // Prototype <= 1.6.1 adds non-standard `toJSON` methods to the\n\t              // `Number`, `String`, `Date`, and `Array` prototypes. JSON 3\n\t              // ignores all `toJSON` methods on these objects unless they are\n\t              // defined directly on an instance.\n\t              value = value.toJSON(property);\n\t            }\n\t          }\n\t          if (callback) {\n\t            // If a replacement function was provided, call it to obtain the value\n\t            // for serialization.\n\t            value = callback.call(object, property, value);\n\t          }\n\t          if (value === null) {\n\t            return \"null\";\n\t          }\n\t          className = getClass.call(value);\n\t          if (className == booleanClass) {\n\t            // Booleans are represented literally.\n\t            return \"\" + value;\n\t          } else if (className == numberClass) {\n\t            // JSON numbers must be finite. `Infinity` and `NaN` are serialized as\n\t            // `\"null\"`.\n\t            return value > -1 / 0 && value < 1 / 0 ? \"\" + value : \"null\";\n\t          } else if (className == stringClass) {\n\t            // Strings are double-quoted and escaped.\n\t            return quote(\"\" + value);\n\t          }\n\t          // Recursively serialize objects and arrays.\n\t          if (typeof value == \"object\") {\n\t            // Check for cyclic structures. This is a linear search; performance\n\t            // is inversely proportional to the number of unique nested objects.\n\t            for (length = stack.length; length--;) {\n\t              if (stack[length] === value) {\n\t                // Cyclic structures cannot be serialized by `JSON.stringify`.\n\t                throw TypeError();\n\t              }\n\t            }\n\t            // Add the object to the stack of traversed objects.\n\t            stack.push(value);\n\t            results = [];\n\t            // Save the current indentation level and indent one additional level.\n\t            prefix = indentation;\n\t            indentation += whitespace;\n\t            if (className == arrayClass) {\n\t              // Recursively serialize array elements.\n\t              for (index = 0, length = value.length; index < length; index++) {\n\t                element = serialize(index, value, callback, properties, whitespace, indentation, stack);\n\t                results.push(element === undef ? \"null\" : element);\n\t              }\n\t              result = results.length ? (whitespace ? \"[\\n\" + indentation + results.join(\",\\n\" + indentation) + \"\\n\" + prefix + \"]\" : (\"[\" + results.join(\",\") + \"]\")) : \"[]\";\n\t            } else {\n\t              // Recursively serialize object members. Members are selected from\n\t              // either a user-specified list of property names, or the object\n\t              // itself.\n\t              forEach(properties || value, function (property) {\n\t                var element = serialize(property, value, callback, properties, whitespace, indentation, stack);\n\t                if (element !== undef) {\n\t                  // According to ES 5.1 section 15.12.3: \"If `gap` {whitespace}\n\t                  // is not the empty string, let `member` {quote(property) + \":\"}\n\t                  // be the concatenation of `member` and the `space` character.\"\n\t                  // The \"`space` character\" refers to the literal space\n\t                  // character, not the `space` {width} argument provided to\n\t                  // `JSON.stringify`.\n\t                  results.push(quote(property) + \":\" + (whitespace ? \" \" : \"\") + element);\n\t                }\n\t              });\n\t              result = results.length ? (whitespace ? \"{\\n\" + indentation + results.join(\",\\n\" + indentation) + \"\\n\" + prefix + \"}\" : (\"{\" + results.join(\",\") + \"}\")) : \"{}\";\n\t            }\n\t            // Remove the object from the traversed object stack.\n\t            stack.pop();\n\t            return result;\n\t          }\n\t        };\n\t\n\t        // Public: `JSON.stringify`. See ES 5.1 section 15.12.3.\n\t        exports.stringify = function (source, filter, width) {\n\t          var whitespace, callback, properties, className;\n\t          if (objectTypes[typeof filter] && filter) {\n\t            if ((className = getClass.call(filter)) == functionClass) {\n\t              callback = filter;\n\t            } else if (className == arrayClass) {\n\t              // Convert the property names array into a makeshift set.\n\t              properties = {};\n\t              for (var index = 0, length = filter.length, value; index < length; value = filter[index++], ((className = getClass.call(value)), className == stringClass || className == numberClass) && (properties[value] = 1));\n\t            }\n\t          }\n\t          if (width) {\n\t            if ((className = getClass.call(width)) == numberClass) {\n\t              // Convert the `width` to an integer and create a string containing\n\t              // `width` number of space characters.\n\t              if ((width -= width % 1) > 0) {\n\t                for (whitespace = \"\", width > 10 && (width = 10); whitespace.length < width; whitespace += \" \");\n\t              }\n\t            } else if (className == stringClass) {\n\t              whitespace = width.length <= 10 ? width : width.slice(0, 10);\n\t            }\n\t          }\n\t          // Opera <= 7.54u2 discards the values associated with empty string keys\n\t          // (`\"\"`) only if they are used directly within an object member list\n\t          // (e.g., `!(\"\" in { \"\": 1})`).\n\t          return serialize(\"\", (value = {}, value[\"\"] = source, value), callback, properties, whitespace, \"\", []);\n\t        };\n\t      }\n\t\n\t      // Public: Parses a JSON source string.\n\t      if (!has(\"json-parse\")) {\n\t        var fromCharCode = String.fromCharCode;\n\t\n\t        // Internal: A map of escaped control characters and their unescaped\n\t        // equivalents.\n\t        var Unescapes = {\n\t          92: \"\\\\\",\n\t          34: '\"',\n\t          47: \"/\",\n\t          98: \"\\b\",\n\t          116: \"\\t\",\n\t          110: \"\\n\",\n\t          102: \"\\f\",\n\t          114: \"\\r\"\n\t        };\n\t\n\t        // Internal: Stores the parser state.\n\t        var Index, Source;\n\t\n\t        // Internal: Resets the parser state and throws a `SyntaxError`.\n\t        var abort = function () {\n\t          Index = Source = null;\n\t          throw SyntaxError();\n\t        };\n\t\n\t        // Internal: Returns the next token, or `\"$\"` if the parser has reached\n\t        // the end of the source string. A token may be a string, number, `null`\n\t        // literal, or Boolean literal.\n\t        var lex = function () {\n\t          var source = Source, length = source.length, value, begin, position, isSigned, charCode;\n\t          while (Index < length) {\n\t            charCode = source.charCodeAt(Index);\n\t            switch (charCode) {\n\t              case 9: case 10: case 13: case 32:\n\t                // Skip whitespace tokens, including tabs, carriage returns, line\n\t                // feeds, and space characters.\n\t                Index++;\n\t                break;\n\t              case 123: case 125: case 91: case 93: case 58: case 44:\n\t                // Parse a punctuator token (`{`, `}`, `[`, `]`, `:`, or `,`) at\n\t                // the current position.\n\t                value = charIndexBuggy ? source.charAt(Index) : source[Index];\n\t                Index++;\n\t                return value;\n\t              case 34:\n\t                // `\"` delimits a JSON string; advance to the next character and\n\t                // begin parsing the string. String tokens are prefixed with the\n\t                // sentinel `@` character to distinguish them from punctuators and\n\t                // end-of-string tokens.\n\t                for (value = \"@\", Index++; Index < length;) {\n\t                  charCode = source.charCodeAt(Index);\n\t                  if (charCode < 32) {\n\t                    // Unescaped ASCII control characters (those with a code unit\n\t                    // less than the space character) are not permitted.\n\t                    abort();\n\t                  } else if (charCode == 92) {\n\t                    // A reverse solidus (`\\`) marks the beginning of an escaped\n\t                    // control character (including `\"`, `\\`, and `/`) or Unicode\n\t                    // escape sequence.\n\t                    charCode = source.charCodeAt(++Index);\n\t                    switch (charCode) {\n\t                      case 92: case 34: case 47: case 98: case 116: case 110: case 102: case 114:\n\t                        // Revive escaped control characters.\n\t                        value += Unescapes[charCode];\n\t                        Index++;\n\t                        break;\n\t                      case 117:\n\t                        // `\\u` marks the beginning of a Unicode escape sequence.\n\t                        // Advance to the first character and validate the\n\t                        // four-digit code point.\n\t                        begin = ++Index;\n\t                        for (position = Index + 4; Index < position; Index++) {\n\t                          charCode = source.charCodeAt(Index);\n\t                          // A valid sequence comprises four hexdigits (case-\n\t                          // insensitive) that form a single hexadecimal value.\n\t                          if (!(charCode >= 48 && charCode <= 57 || charCode >= 97 && charCode <= 102 || charCode >= 65 && charCode <= 70)) {\n\t                            // Invalid Unicode escape sequence.\n\t                            abort();\n\t                          }\n\t                        }\n\t                        // Revive the escaped character.\n\t                        value += fromCharCode(\"0x\" + source.slice(begin, Index));\n\t                        break;\n\t                      default:\n\t                        // Invalid escape sequence.\n\t                        abort();\n\t                    }\n\t                  } else {\n\t                    if (charCode == 34) {\n\t                      // An unescaped double-quote character marks the end of the\n\t                      // string.\n\t                      break;\n\t                    }\n\t                    charCode = source.charCodeAt(Index);\n\t                    begin = Index;\n\t                    // Optimize for the common case where a string is valid.\n\t                    while (charCode >= 32 && charCode != 92 && charCode != 34) {\n\t                      charCode = source.charCodeAt(++Index);\n\t                    }\n\t                    // Append the string as-is.\n\t                    value += source.slice(begin, Index);\n\t                  }\n\t                }\n\t                if (source.charCodeAt(Index) == 34) {\n\t                  // Advance to the next character and return the revived string.\n\t                  Index++;\n\t                  return value;\n\t                }\n\t                // Unterminated string.\n\t                abort();\n\t              default:\n\t                // Parse numbers and literals.\n\t                begin = Index;\n\t                // Advance past the negative sign, if one is specified.\n\t                if (charCode == 45) {\n\t                  isSigned = true;\n\t                  charCode = source.charCodeAt(++Index);\n\t                }\n\t                // Parse an integer or floating-point value.\n\t                if (charCode >= 48 && charCode <= 57) {\n\t                  // Leading zeroes are interpreted as octal literals.\n\t                  if (charCode == 48 && ((charCode = source.charCodeAt(Index + 1)), charCode >= 48 && charCode <= 57)) {\n\t                    // Illegal octal literal.\n\t                    abort();\n\t                  }\n\t                  isSigned = false;\n\t                  // Parse the integer component.\n\t                  for (; Index < length && ((charCode = source.charCodeAt(Index)), charCode >= 48 && charCode <= 57); Index++);\n\t                  // Floats cannot contain a leading decimal point; however, this\n\t                  // case is already accounted for by the parser.\n\t                  if (source.charCodeAt(Index) == 46) {\n\t                    position = ++Index;\n\t                    // Parse the decimal component.\n\t                    for (; position < length && ((charCode = source.charCodeAt(position)), charCode >= 48 && charCode <= 57); position++);\n\t                    if (position == Index) {\n\t                      // Illegal trailing decimal.\n\t                      abort();\n\t                    }\n\t                    Index = position;\n\t                  }\n\t                  // Parse exponents. The `e` denoting the exponent is\n\t                  // case-insensitive.\n\t                  charCode = source.charCodeAt(Index);\n\t                  if (charCode == 101 || charCode == 69) {\n\t                    charCode = source.charCodeAt(++Index);\n\t                    // Skip past the sign following the exponent, if one is\n\t                    // specified.\n\t                    if (charCode == 43 || charCode == 45) {\n\t                      Index++;\n\t                    }\n\t                    // Parse the exponential component.\n\t                    for (position = Index; position < length && ((charCode = source.charCodeAt(position)), charCode >= 48 && charCode <= 57); position++);\n\t                    if (position == Index) {\n\t                      // Illegal empty exponent.\n\t                      abort();\n\t                    }\n\t                    Index = position;\n\t                  }\n\t                  // Coerce the parsed value to a JavaScript number.\n\t                  return +source.slice(begin, Index);\n\t                }\n\t                // A negative sign may only precede numbers.\n\t                if (isSigned) {\n\t                  abort();\n\t                }\n\t                // `true`, `false`, and `null` literals.\n\t                if (source.slice(Index, Index + 4) == \"true\") {\n\t                  Index += 4;\n\t                  return true;\n\t                } else if (source.slice(Index, Index + 5) == \"false\") {\n\t                  Index += 5;\n\t                  return false;\n\t                } else if (source.slice(Index, Index + 4) == \"null\") {\n\t                  Index += 4;\n\t                  return null;\n\t                }\n\t                // Unrecognized token.\n\t                abort();\n\t            }\n\t          }\n\t          // Return the sentinel `$` character if the parser has reached the end\n\t          // of the source string.\n\t          return \"$\";\n\t        };\n\t\n\t        // Internal: Parses a JSON `value` token.\n\t        var get = function (value) {\n\t          var results, hasMembers;\n\t          if (value == \"$\") {\n\t            // Unexpected end of input.\n\t            abort();\n\t          }\n\t          if (typeof value == \"string\") {\n\t            if ((charIndexBuggy ? value.charAt(0) : value[0]) == \"@\") {\n\t              // Remove the sentinel `@` character.\n\t              return value.slice(1);\n\t            }\n\t            // Parse object and array literals.\n\t            if (value == \"[\") {\n\t              // Parses a JSON array, returning a new JavaScript array.\n\t              results = [];\n\t              for (;; hasMembers || (hasMembers = true)) {\n\t                value = lex();\n\t                // A closing square bracket marks the end of the array literal.\n\t                if (value == \"]\") {\n\t                  break;\n\t                }\n\t                // If the array literal contains elements, the current token\n\t                // should be a comma separating the previous element from the\n\t                // next.\n\t                if (hasMembers) {\n\t                  if (value == \",\") {\n\t                    value = lex();\n\t                    if (value == \"]\") {\n\t                      // Unexpected trailing `,` in array literal.\n\t                      abort();\n\t                    }\n\t                  } else {\n\t                    // A `,` must separate each array element.\n\t                    abort();\n\t                  }\n\t                }\n\t                // Elisions and leading commas are not permitted.\n\t                if (value == \",\") {\n\t                  abort();\n\t                }\n\t                results.push(get(value));\n\t              }\n\t              return results;\n\t            } else if (value == \"{\") {\n\t              // Parses a JSON object, returning a new JavaScript object.\n\t              results = {};\n\t              for (;; hasMembers || (hasMembers = true)) {\n\t                value = lex();\n\t                // A closing curly brace marks the end of the object literal.\n\t                if (value == \"}\") {\n\t                  break;\n\t                }\n\t                // If the object literal contains members, the current token\n\t                // should be a comma separator.\n\t                if (hasMembers) {\n\t                  if (value == \",\") {\n\t                    value = lex();\n\t                    if (value == \"}\") {\n\t                      // Unexpected trailing `,` in object literal.\n\t                      abort();\n\t                    }\n\t                  } else {\n\t                    // A `,` must separate each object member.\n\t                    abort();\n\t                  }\n\t                }\n\t                // Leading commas are not permitted, object property names must be\n\t                // double-quoted strings, and a `:` must separate each property\n\t                // name and value.\n\t                if (value == \",\" || typeof value != \"string\" || (charIndexBuggy ? value.charAt(0) : value[0]) != \"@\" || lex() != \":\") {\n\t                  abort();\n\t                }\n\t                results[value.slice(1)] = get(lex());\n\t              }\n\t              return results;\n\t            }\n\t            // Unexpected token encountered.\n\t            abort();\n\t          }\n\t          return value;\n\t        };\n\t\n\t        // Internal: Updates a traversed object member.\n\t        var update = function (source, property, callback) {\n\t          var element = walk(source, property, callback);\n\t          if (element === undef) {\n\t            delete source[property];\n\t          } else {\n\t            source[property] = element;\n\t          }\n\t        };\n\t\n\t        // Internal: Recursively traverses a parsed JSON object, invoking the\n\t        // `callback` function for each value. This is an implementation of the\n\t        // `Walk(holder, name)` operation defined in ES 5.1 section 15.12.2.\n\t        var walk = function (source, property, callback) {\n\t          var value = source[property], length;\n\t          if (typeof value == \"object\" && value) {\n\t            // `forEach` can't be used to traverse an array in Opera <= 8.54\n\t            // because its `Object#hasOwnProperty` implementation returns `false`\n\t            // for array indices (e.g., `![1, 2, 3].hasOwnProperty(\"0\")`).\n\t            if (getClass.call(value) == arrayClass) {\n\t              for (length = value.length; length--;) {\n\t                update(value, length, callback);\n\t              }\n\t            } else {\n\t              forEach(value, function (property) {\n\t                update(value, property, callback);\n\t              });\n\t            }\n\t          }\n\t          return callback.call(source, property, value);\n\t        };\n\t\n\t        // Public: `JSON.parse`. See ES 5.1 section 15.12.2.\n\t        exports.parse = function (source, callback) {\n\t          var result, value;\n\t          Index = 0;\n\t          Source = \"\" + source;\n\t          result = get(lex());\n\t          // If a JSON string contains multiple tokens, it is invalid.\n\t          if (lex() != \"$\") {\n\t            abort();\n\t          }\n\t          // Reset the parser state.\n\t          Index = Source = null;\n\t          return callback && getClass.call(callback) == functionClass ? walk((value = {}, value[\"\"] = result, value), \"\", callback) : result;\n\t        };\n\t      }\n\t    }\n\t\n\t    exports[\"runInContext\"] = runInContext;\n\t    return exports;\n\t  }\n\t\n\t  if (freeExports && !isLoader) {\n\t    // Export for CommonJS environments.\n\t    runInContext(root, freeExports);\n\t  } else {\n\t    // Export for web browsers and JavaScript engines.\n\t    var nativeJSON = root.JSON,\n\t        previousJSON = root[\"JSON3\"],\n\t        isRestored = false;\n\t\n\t    var JSON3 = runInContext(root, (root[\"JSON3\"] = {\n\t      // Public: Restores the original value of the global `JSON` object and\n\t      // returns a reference to the `JSON3` object.\n\t      \"noConflict\": function () {\n\t        if (!isRestored) {\n\t          isRestored = true;\n\t          root.JSON = nativeJSON;\n\t          root[\"JSON3\"] = previousJSON;\n\t          nativeJSON = previousJSON = null;\n\t        }\n\t        return JSON3;\n\t      }\n\t    }));\n\t\n\t    root.JSON = {\n\t      \"parse\": JSON3.parse,\n\t      \"stringify\": JSON3.stringify\n\t    };\n\t  }\n\t\n\t  // Export for asynchronous module loaders.\n\t  if (isLoader) {\n\t    !(__WEBPACK_AMD_DEFINE_RESULT__ = function () {\n\t      return JSON3;\n\t    }.call(exports, __webpack_require__, exports, module), __WEBPACK_AMD_DEFINE_RESULT__ !== undefined && (module.exports = __WEBPACK_AMD_DEFINE_RESULT__));\n\t  }\n\t}).call(this);\n\t\n\t/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(457)(module), (function() { return this; }())))\n\n/***/ },\n\n/***/ 457:\n/***/ function(module, exports) {\n\n\tmodule.exports = function(module) {\r\n\t\tif(!module.webpackPolyfill) {\r\n\t\t\tmodule.deprecate = function() {};\r\n\t\t\tmodule.paths = [];\r\n\t\t\t// module.parent = undefined by default\r\n\t\t\tmodule.children = [];\r\n\t\t\tmodule.webpackPolyfill = 1;\r\n\t\t}\r\n\t\treturn module;\r\n\t}\r\n\n\n/***/ },\n\n/***/ 458:\n/***/ function(module, exports) {\n\n\t/* WEBPACK VAR INJECTION */(function(__webpack_amd_options__) {module.exports = __webpack_amd_options__;\r\n\t\n\t/* WEBPACK VAR INJECTION */}.call(exports, {}))\n\n/***/ },\n\n/***/ 459:\n/***/ function(module, exports) {\n\n\t\n\t/**\n\t * Expose `Emitter`.\n\t */\n\t\n\tmodule.exports = Emitter;\n\t\n\t/**\n\t * Initialize a new `Emitter`.\n\t *\n\t * @api public\n\t */\n\t\n\tfunction Emitter(obj) {\n\t  if (obj) return mixin(obj);\n\t};\n\t\n\t/**\n\t * Mixin the emitter properties.\n\t *\n\t * @param {Object} obj\n\t * @return {Object}\n\t * @api private\n\t */\n\t\n\tfunction mixin(obj) {\n\t  for (var key in Emitter.prototype) {\n\t    obj[key] = Emitter.prototype[key];\n\t  }\n\t  return obj;\n\t}\n\t\n\t/**\n\t * Listen on the given `event` with `fn`.\n\t *\n\t * @param {String} event\n\t * @param {Function} fn\n\t * @return {Emitter}\n\t * @api public\n\t */\n\t\n\tEmitter.prototype.on =\n\tEmitter.prototype.addEventListener = function(event, fn){\n\t  this._callbacks = this._callbacks || {};\n\t  (this._callbacks[event] = this._callbacks[event] || [])\n\t    .push(fn);\n\t  return this;\n\t};\n\t\n\t/**\n\t * Adds an `event` listener that will be invoked a single\n\t * time then automatically removed.\n\t *\n\t * @param {String} event\n\t * @param {Function} fn\n\t * @return {Emitter}\n\t * @api public\n\t */\n\t\n\tEmitter.prototype.once = function(event, fn){\n\t  var self = this;\n\t  this._callbacks = this._callbacks || {};\n\t\n\t  function on() {\n\t    self.off(event, on);\n\t    fn.apply(this, arguments);\n\t  }\n\t\n\t  on.fn = fn;\n\t  this.on(event, on);\n\t  return this;\n\t};\n\t\n\t/**\n\t * Remove the given callback for `event` or all\n\t * registered callbacks.\n\t *\n\t * @param {String} event\n\t * @param {Function} fn\n\t * @return {Emitter}\n\t * @api public\n\t */\n\t\n\tEmitter.prototype.off =\n\tEmitter.prototype.removeListener =\n\tEmitter.prototype.removeAllListeners =\n\tEmitter.prototype.removeEventListener = function(event, fn){\n\t  this._callbacks = this._callbacks || {};\n\t\n\t  // all\n\t  if (0 == arguments.length) {\n\t    this._callbacks = {};\n\t    return this;\n\t  }\n\t\n\t  // specific event\n\t  var callbacks = this._callbacks[event];\n\t  if (!callbacks) return this;\n\t\n\t  // remove all handlers\n\t  if (1 == arguments.length) {\n\t    delete this._callbacks[event];\n\t    return this;\n\t  }\n\t\n\t  // remove specific handler\n\t  var cb;\n\t  for (var i = 0; i < callbacks.length; i++) {\n\t    cb = callbacks[i];\n\t    if (cb === fn || cb.fn === fn) {\n\t      callbacks.splice(i, 1);\n\t      break;\n\t    }\n\t  }\n\t  return this;\n\t};\n\t\n\t/**\n\t * Emit `event` with the given args.\n\t *\n\t * @param {String} event\n\t * @param {Mixed} ...\n\t * @return {Emitter}\n\t */\n\t\n\tEmitter.prototype.emit = function(event){\n\t  this._callbacks = this._callbacks || {};\n\t  var args = [].slice.call(arguments, 1)\n\t    , callbacks = this._callbacks[event];\n\t\n\t  if (callbacks) {\n\t    callbacks = callbacks.slice(0);\n\t    for (var i = 0, len = callbacks.length; i < len; ++i) {\n\t      callbacks[i].apply(this, args);\n\t    }\n\t  }\n\t\n\t  return this;\n\t};\n\t\n\t/**\n\t * Return array of callbacks for `event`.\n\t *\n\t * @param {String} event\n\t * @return {Array}\n\t * @api public\n\t */\n\t\n\tEmitter.prototype.listeners = function(event){\n\t  this._callbacks = this._callbacks || {};\n\t  return this._callbacks[event] || [];\n\t};\n\t\n\t/**\n\t * Check if this emitter has `event` handlers.\n\t *\n\t * @param {String} event\n\t * @return {Boolean}\n\t * @api public\n\t */\n\t\n\tEmitter.prototype.hasListeners = function(event){\n\t  return !! this.listeners(event).length;\n\t};\n\n\n/***/ },\n\n/***/ 460:\n/***/ function(module, exports, __webpack_require__) {\n\n\t/* WEBPACK VAR INJECTION */(function(global) {/*global Blob,File*/\n\t\n\t/**\n\t * Module requirements\n\t */\n\t\n\tvar isArray = __webpack_require__(461);\n\tvar isBuf = __webpack_require__(462);\n\t\n\t/**\n\t * Replaces every Buffer | ArrayBuffer in packet with a numbered placeholder.\n\t * Anything with blobs or files should be fed through removeBlobs before coming\n\t * here.\n\t *\n\t * @param {Object} packet - socket.io event packet\n\t * @return {Object} with deconstructed packet and list of buffers\n\t * @api public\n\t */\n\t\n\texports.deconstructPacket = function(packet){\n\t  var buffers = [];\n\t  var packetData = packet.data;\n\t\n\t  function _deconstructPacket(data) {\n\t    if (!data) return data;\n\t\n\t    if (isBuf(data)) {\n\t      var placeholder = { _placeholder: true, num: buffers.length };\n\t      buffers.push(data);\n\t      return placeholder;\n\t    } else if (isArray(data)) {\n\t      var newData = new Array(data.length);\n\t      for (var i = 0; i < data.length; i++) {\n\t        newData[i] = _deconstructPacket(data[i]);\n\t      }\n\t      return newData;\n\t    } else if ('object' == typeof data && !(data instanceof Date)) {\n\t      var newData = {};\n\t      for (var key in data) {\n\t        newData[key] = _deconstructPacket(data[key]);\n\t      }\n\t      return newData;\n\t    }\n\t    return data;\n\t  }\n\t\n\t  var pack = packet;\n\t  pack.data = _deconstructPacket(packetData);\n\t  pack.attachments = buffers.length; // number of binary 'attachments'\n\t  return {packet: pack, buffers: buffers};\n\t};\n\t\n\t/**\n\t * Reconstructs a binary packet from its placeholder packet and buffers\n\t *\n\t * @param {Object} packet - event packet with placeholders\n\t * @param {Array} buffers - binary buffers to put in placeholder positions\n\t * @return {Object} reconstructed packet\n\t * @api public\n\t */\n\t\n\texports.reconstructPacket = function(packet, buffers) {\n\t  var curPlaceHolder = 0;\n\t\n\t  function _reconstructPacket(data) {\n\t    if (data && data._placeholder) {\n\t      var buf = buffers[data.num]; // appropriate buffer (should be natural order anyway)\n\t      return buf;\n\t    } else if (isArray(data)) {\n\t      for (var i = 0; i < data.length; i++) {\n\t        data[i] = _reconstructPacket(data[i]);\n\t      }\n\t      return data;\n\t    } else if (data && 'object' == typeof data) {\n\t      for (var key in data) {\n\t        data[key] = _reconstructPacket(data[key]);\n\t      }\n\t      return data;\n\t    }\n\t    return data;\n\t  }\n\t\n\t  packet.data = _reconstructPacket(packet.data);\n\t  packet.attachments = undefined; // no longer useful\n\t  return packet;\n\t};\n\t\n\t/**\n\t * Asynchronously removes Blobs or Files from data via\n\t * FileReader's readAsArrayBuffer method. Used before encoding\n\t * data as msgpack. Calls callback with the blobless data.\n\t *\n\t * @param {Object} data\n\t * @param {Function} callback\n\t * @api private\n\t */\n\t\n\texports.removeBlobs = function(data, callback) {\n\t  function _removeBlobs(obj, curKey, containingObject) {\n\t    if (!obj) return obj;\n\t\n\t    // convert any blob\n\t    if ((global.Blob && obj instanceof Blob) ||\n\t        (global.File && obj instanceof File)) {\n\t      pendingBlobs++;\n\t\n\t      // async filereader\n\t      var fileReader = new FileReader();\n\t      fileReader.onload = function() { // this.result == arraybuffer\n\t        if (containingObject) {\n\t          containingObject[curKey] = this.result;\n\t        }\n\t        else {\n\t          bloblessData = this.result;\n\t        }\n\t\n\t        // if nothing pending its callback time\n\t        if(! --pendingBlobs) {\n\t          callback(bloblessData);\n\t        }\n\t      };\n\t\n\t      fileReader.readAsArrayBuffer(obj); // blob -> arraybuffer\n\t    } else if (isArray(obj)) { // handle array\n\t      for (var i = 0; i < obj.length; i++) {\n\t        _removeBlobs(obj[i], i, obj);\n\t      }\n\t    } else if (obj && 'object' == typeof obj && !isBuf(obj)) { // and object\n\t      for (var key in obj) {\n\t        _removeBlobs(obj[key], key, obj);\n\t      }\n\t    }\n\t  }\n\t\n\t  var pendingBlobs = 0;\n\t  var bloblessData = data;\n\t  _removeBlobs(bloblessData);\n\t  if (!pendingBlobs) {\n\t    callback(bloblessData);\n\t  }\n\t};\n\t\n\t/* WEBPACK VAR INJECTION */}.call(exports, (function() { return this; }())))\n\n/***/ },\n\n/***/ 461:\n/***/ function(module, exports) {\n\n\tmodule.exports = Array.isArray || function (arr) {\n\t  return Object.prototype.toString.call(arr) == '[object Array]';\n\t};\n\n\n/***/ },\n\n/***/ 462:\n/***/ function(module, exports) {\n\n\t/* WEBPACK VAR INJECTION */(function(global) {\n\tmodule.exports = isBuf;\n\t\n\t/**\n\t * Returns true if obj is a buffer or an arraybuffer.\n\t *\n\t * @api private\n\t */\n\t\n\tfunction isBuf(obj) {\n\t  return (global.Buffer && global.Buffer.isBuffer(obj)) ||\n\t         (global.ArrayBuffer && obj instanceof ArrayBuffer);\n\t}\n\t\n\t/* WEBPACK VAR INJECTION */}.call(exports, (function() { return this; }())))\n\n/***/ },\n\n/***/ 463:\n/***/ function(module, exports, __webpack_require__) {\n\n\t\n\t/**\n\t * Module dependencies.\n\t */\n\t\n\tvar eio = __webpack_require__(464);\n\tvar Socket = __webpack_require__(493);\n\tvar Emitter = __webpack_require__(494);\n\tvar parser = __webpack_require__(452);\n\tvar on = __webpack_require__(496);\n\tvar bind = __webpack_require__(497);\n\tvar debug = __webpack_require__(449)('socket.io-client:manager');\n\tvar indexOf = __webpack_require__(491);\n\tvar Backoff = __webpack_require__(498);\n\t\n\t/**\n\t * IE6+ hasOwnProperty\n\t */\n\t\n\tvar has = Object.prototype.hasOwnProperty;\n\t\n\t/**\n\t * Module exports\n\t */\n\t\n\tmodule.exports = Manager;\n\t\n\t/**\n\t * `Manager` constructor.\n\t *\n\t * @param {String} engine instance or engine uri/opts\n\t * @param {Object} options\n\t * @api public\n\t */\n\t\n\tfunction Manager (uri, opts) {\n\t  if (!(this instanceof Manager)) return new Manager(uri, opts);\n\t  if (uri && ('object' === typeof uri)) {\n\t    opts = uri;\n\t    uri = undefined;\n\t  }\n\t  opts = opts || {};\n\t\n\t  opts.path = opts.path || '/socket.io';\n\t  this.nsps = {};\n\t  this.subs = [];\n\t  this.opts = opts;\n\t  this.reconnection(opts.reconnection !== false);\n\t  this.reconnectionAttempts(opts.reconnectionAttempts || Infinity);\n\t  this.reconnectionDelay(opts.reconnectionDelay || 1000);\n\t  this.reconnectionDelayMax(opts.reconnectionDelayMax || 5000);\n\t  this.randomizationFactor(opts.randomizationFactor || 0.5);\n\t  this.backoff = new Backoff({\n\t    min: this.reconnectionDelay(),\n\t    max: this.reconnectionDelayMax(),\n\t    jitter: this.randomizationFactor()\n\t  });\n\t  this.timeout(null == opts.timeout ? 20000 : opts.timeout);\n\t  this.readyState = 'closed';\n\t  this.uri = uri;\n\t  this.connecting = [];\n\t  this.lastPing = null;\n\t  this.encoding = false;\n\t  this.packetBuffer = [];\n\t  this.encoder = new parser.Encoder();\n\t  this.decoder = new parser.Decoder();\n\t  this.autoConnect = opts.autoConnect !== false;\n\t  if (this.autoConnect) this.open();\n\t}\n\t\n\t/**\n\t * Propagate given event to sockets and emit on `this`\n\t *\n\t * @api private\n\t */\n\t\n\tManager.prototype.emitAll = function () {\n\t  this.emit.apply(this, arguments);\n\t  for (var nsp in this.nsps) {\n\t    if (has.call(this.nsps, nsp)) {\n\t      this.nsps[nsp].emit.apply(this.nsps[nsp], arguments);\n\t    }\n\t  }\n\t};\n\t\n\t/**\n\t * Update `socket.id` of all sockets\n\t *\n\t * @api private\n\t */\n\t\n\tManager.prototype.updateSocketIds = function () {\n\t  for (var nsp in this.nsps) {\n\t    if (has.call(this.nsps, nsp)) {\n\t      this.nsps[nsp].id = this.engine.id;\n\t    }\n\t  }\n\t};\n\t\n\t/**\n\t * Mix in `Emitter`.\n\t */\n\t\n\tEmitter(Manager.prototype);\n\t\n\t/**\n\t * Sets the `reconnection` config.\n\t *\n\t * @param {Boolean} true/false if it should automatically reconnect\n\t * @return {Manager} self or value\n\t * @api public\n\t */\n\t\n\tManager.prototype.reconnection = function (v) {\n\t  if (!arguments.length) return this._reconnection;\n\t  this._reconnection = !!v;\n\t  return this;\n\t};\n\t\n\t/**\n\t * Sets the reconnection attempts config.\n\t *\n\t * @param {Number} max reconnection attempts before giving up\n\t * @return {Manager} self or value\n\t * @api public\n\t */\n\t\n\tManager.prototype.reconnectionAttempts = function (v) {\n\t  if (!arguments.length) return this._reconnectionAttempts;\n\t  this._reconnectionAttempts = v;\n\t  return this;\n\t};\n\t\n\t/**\n\t * Sets the delay between reconnections.\n\t *\n\t * @param {Number} delay\n\t * @return {Manager} self or value\n\t * @api public\n\t */\n\t\n\tManager.prototype.reconnectionDelay = function (v) {\n\t  if (!arguments.length) return this._reconnectionDelay;\n\t  this._reconnectionDelay = v;\n\t  this.backoff && this.backoff.setMin(v);\n\t  return this;\n\t};\n\t\n\tManager.prototype.randomizationFactor = function (v) {\n\t  if (!arguments.length) return this._randomizationFactor;\n\t  this._randomizationFactor = v;\n\t  this.backoff && this.backoff.setJitter(v);\n\t  return this;\n\t};\n\t\n\t/**\n\t * Sets the maximum delay between reconnections.\n\t *\n\t * @param {Number} delay\n\t * @return {Manager} self or value\n\t * @api public\n\t */\n\t\n\tManager.prototype.reconnectionDelayMax = function (v) {\n\t  if (!arguments.length) return this._reconnectionDelayMax;\n\t  this._reconnectionDelayMax = v;\n\t  this.backoff && this.backoff.setMax(v);\n\t  return this;\n\t};\n\t\n\t/**\n\t * Sets the connection timeout. `false` to disable\n\t *\n\t * @return {Manager} self or value\n\t * @api public\n\t */\n\t\n\tManager.prototype.timeout = function (v) {\n\t  if (!arguments.length) return this._timeout;\n\t  this._timeout = v;\n\t  return this;\n\t};\n\t\n\t/**\n\t * Starts trying to reconnect if reconnection is enabled and we have not\n\t * started reconnecting yet\n\t *\n\t * @api private\n\t */\n\t\n\tManager.prototype.maybeReconnectOnOpen = function () {\n\t  // Only try to reconnect if it's the first time we're connecting\n\t  if (!this.reconnecting && this._reconnection && this.backoff.attempts === 0) {\n\t    // keeps reconnection from firing twice for the same reconnection loop\n\t    this.reconnect();\n\t  }\n\t};\n\t\n\t/**\n\t * Sets the current transport `socket`.\n\t *\n\t * @param {Function} optional, callback\n\t * @return {Manager} self\n\t * @api public\n\t */\n\t\n\tManager.prototype.open =\n\tManager.prototype.connect = function (fn, opts) {\n\t  debug('readyState %s', this.readyState);\n\t  if (~this.readyState.indexOf('open')) return this;\n\t\n\t  debug('opening %s', this.uri);\n\t  this.engine = eio(this.uri, this.opts);\n\t  var socket = this.engine;\n\t  var self = this;\n\t  this.readyState = 'opening';\n\t  this.skipReconnect = false;\n\t\n\t  // emit `open`\n\t  var openSub = on(socket, 'open', function () {\n\t    self.onopen();\n\t    fn && fn();\n\t  });\n\t\n\t  // emit `connect_error`\n\t  var errorSub = on(socket, 'error', function (data) {\n\t    debug('connect_error');\n\t    self.cleanup();\n\t    self.readyState = 'closed';\n\t    self.emitAll('connect_error', data);\n\t    if (fn) {\n\t      var err = new Error('Connection error');\n\t      err.data = data;\n\t      fn(err);\n\t    } else {\n\t      // Only do this if there is no fn to handle the error\n\t      self.maybeReconnectOnOpen();\n\t    }\n\t  });\n\t\n\t  // emit `connect_timeout`\n\t  if (false !== this._timeout) {\n\t    var timeout = this._timeout;\n\t    debug('connect attempt will timeout after %d', timeout);\n\t\n\t    // set timer\n\t    var timer = setTimeout(function () {\n\t      debug('connect attempt timed out after %d', timeout);\n\t      openSub.destroy();\n\t      socket.close();\n\t      socket.emit('error', 'timeout');\n\t      self.emitAll('connect_timeout', timeout);\n\t    }, timeout);\n\t\n\t    this.subs.push({\n\t      destroy: function () {\n\t        clearTimeout(timer);\n\t      }\n\t    });\n\t  }\n\t\n\t  this.subs.push(openSub);\n\t  this.subs.push(errorSub);\n\t\n\t  return this;\n\t};\n\t\n\t/**\n\t * Called upon transport open.\n\t *\n\t * @api private\n\t */\n\t\n\tManager.prototype.onopen = function () {\n\t  debug('open');\n\t\n\t  // clear old subs\n\t  this.cleanup();\n\t\n\t  // mark as open\n\t  this.readyState = 'open';\n\t  this.emit('open');\n\t\n\t  // add new subs\n\t  var socket = this.engine;\n\t  this.subs.push(on(socket, 'data', bind(this, 'ondata')));\n\t  this.subs.push(on(socket, 'ping', bind(this, 'onping')));\n\t  this.subs.push(on(socket, 'pong', bind(this, 'onpong')));\n\t  this.subs.push(on(socket, 'error', bind(this, 'onerror')));\n\t  this.subs.push(on(socket, 'close', bind(this, 'onclose')));\n\t  this.subs.push(on(this.decoder, 'decoded', bind(this, 'ondecoded')));\n\t};\n\t\n\t/**\n\t * Called upon a ping.\n\t *\n\t * @api private\n\t */\n\t\n\tManager.prototype.onping = function () {\n\t  this.lastPing = new Date();\n\t  this.emitAll('ping');\n\t};\n\t\n\t/**\n\t * Called upon a packet.\n\t *\n\t * @api private\n\t */\n\t\n\tManager.prototype.onpong = function () {\n\t  this.emitAll('pong', new Date() - this.lastPing);\n\t};\n\t\n\t/**\n\t * Called with data.\n\t *\n\t * @api private\n\t */\n\t\n\tManager.prototype.ondata = function (data) {\n\t  this.decoder.add(data);\n\t};\n\t\n\t/**\n\t * Called when parser fully decodes a packet.\n\t *\n\t * @api private\n\t */\n\t\n\tManager.prototype.ondecoded = function (packet) {\n\t  this.emit('packet', packet);\n\t};\n\t\n\t/**\n\t * Called upon socket error.\n\t *\n\t * @api private\n\t */\n\t\n\tManager.prototype.onerror = function (err) {\n\t  debug('error', err);\n\t  this.emitAll('error', err);\n\t};\n\t\n\t/**\n\t * Creates a new socket for the given `nsp`.\n\t *\n\t * @return {Socket}\n\t * @api public\n\t */\n\t\n\tManager.prototype.socket = function (nsp, opts) {\n\t  var socket = this.nsps[nsp];\n\t  if (!socket) {\n\t    socket = new Socket(this, nsp, opts);\n\t    this.nsps[nsp] = socket;\n\t    var self = this;\n\t    socket.on('connecting', onConnecting);\n\t    socket.on('connect', function () {\n\t      socket.id = self.engine.id;\n\t    });\n\t\n\t    if (this.autoConnect) {\n\t      // manually call here since connecting evnet is fired before listening\n\t      onConnecting();\n\t    }\n\t  }\n\t\n\t  function onConnecting () {\n\t    if (!~indexOf(self.connecting, socket)) {\n\t      self.connecting.push(socket);\n\t    }\n\t  }\n\t\n\t  return socket;\n\t};\n\t\n\t/**\n\t * Called upon a socket close.\n\t *\n\t * @param {Socket} socket\n\t */\n\t\n\tManager.prototype.destroy = function (socket) {\n\t  var index = indexOf(this.connecting, socket);\n\t  if (~index) this.connecting.splice(index, 1);\n\t  if (this.connecting.length) return;\n\t\n\t  this.close();\n\t};\n\t\n\t/**\n\t * Writes a packet.\n\t *\n\t * @param {Object} packet\n\t * @api private\n\t */\n\t\n\tManager.prototype.packet = function (packet) {\n\t  debug('writing packet %j', packet);\n\t  var self = this;\n\t  if (packet.query && packet.type === 0) packet.nsp += '?' + packet.query;\n\t\n\t  if (!self.encoding) {\n\t    // encode, then write to engine with result\n\t    self.encoding = true;\n\t    this.encoder.encode(packet, function (encodedPackets) {\n\t      for (var i = 0; i < encodedPackets.length; i++) {\n\t        self.engine.write(encodedPackets[i], packet.options);\n\t      }\n\t      self.encoding = false;\n\t      self.processPacketQueue();\n\t    });\n\t  } else { // add packet to the queue\n\t    self.packetBuffer.push(packet);\n\t  }\n\t};\n\t\n\t/**\n\t * If packet buffer is non-empty, begins encoding the\n\t * next packet in line.\n\t *\n\t * @api private\n\t */\n\t\n\tManager.prototype.processPacketQueue = function () {\n\t  if (this.packetBuffer.length > 0 && !this.encoding) {\n\t    var pack = this.packetBuffer.shift();\n\t    this.packet(pack);\n\t  }\n\t};\n\t\n\t/**\n\t * Clean up transport subscriptions and packet buffer.\n\t *\n\t * @api private\n\t */\n\t\n\tManager.prototype.cleanup = function () {\n\t  debug('cleanup');\n\t\n\t  var subsLength = this.subs.length;\n\t  for (var i = 0; i < subsLength; i++) {\n\t    var sub = this.subs.shift();\n\t    sub.destroy();\n\t  }\n\t\n\t  this.packetBuffer = [];\n\t  this.encoding = false;\n\t  this.lastPing = null;\n\t\n\t  this.decoder.destroy();\n\t};\n\t\n\t/**\n\t * Close the current socket.\n\t *\n\t * @api private\n\t */\n\t\n\tManager.prototype.close =\n\tManager.prototype.disconnect = function () {\n\t  debug('disconnect');\n\t  this.skipReconnect = true;\n\t  this.reconnecting = false;\n\t  if ('opening' === this.readyState) {\n\t    // `onclose` will not fire because\n\t    // an open event never happened\n\t    this.cleanup();\n\t  }\n\t  this.backoff.reset();\n\t  this.readyState = 'closed';\n\t  if (this.engine) this.engine.close();\n\t};\n\t\n\t/**\n\t * Called upon engine close.\n\t *\n\t * @api private\n\t */\n\t\n\tManager.prototype.onclose = function (reason) {\n\t  debug('onclose');\n\t\n\t  this.cleanup();\n\t  this.backoff.reset();\n\t  this.readyState = 'closed';\n\t  this.emit('close', reason);\n\t\n\t  if (this._reconnection && !this.skipReconnect) {\n\t    this.reconnect();\n\t  }\n\t};\n\t\n\t/**\n\t * Attempt a reconnection.\n\t *\n\t * @api private\n\t */\n\t\n\tManager.prototype.reconnect = function () {\n\t  if (this.reconnecting || this.skipReconnect) return this;\n\t\n\t  var self = this;\n\t\n\t  if (this.backoff.attempts >= this._reconnectionAttempts) {\n\t    debug('reconnect failed');\n\t    this.backoff.reset();\n\t    this.emitAll('reconnect_failed');\n\t    this.reconnecting = false;\n\t  } else {\n\t    var delay = this.backoff.duration();\n\t    debug('will wait %dms before reconnect attempt', delay);\n\t\n\t    this.reconnecting = true;\n\t    var timer = setTimeout(function () {\n\t      if (self.skipReconnect) return;\n\t\n\t      debug('attempting reconnect');\n\t      self.emitAll('reconnect_attempt', self.backoff.attempts);\n\t      self.emitAll('reconnecting', self.backoff.attempts);\n\t\n\t      // check again for the case socket closed in above events\n\t      if (self.skipReconnect) return;\n\t\n\t      self.open(function (err) {\n\t        if (err) {\n\t          debug('reconnect attempt error');\n\t          self.reconnecting = false;\n\t          self.reconnect();\n\t          self.emitAll('reconnect_error', err.data);\n\t        } else {\n\t          debug('reconnect success');\n\t          self.onreconnect();\n\t        }\n\t      });\n\t    }, delay);\n\t\n\t    this.subs.push({\n\t      destroy: function () {\n\t        clearTimeout(timer);\n\t      }\n\t    });\n\t  }\n\t};\n\t\n\t/**\n\t * Called upon successful reconnect.\n\t *\n\t * @api private\n\t */\n\t\n\tManager.prototype.onreconnect = function () {\n\t  var attempt = this.backoff.attempts;\n\t  this.reconnecting = false;\n\t  this.backoff.reset();\n\t  this.updateSocketIds();\n\t  this.emitAll('reconnect', attempt);\n\t};\n\n\n/***/ },\n\n/***/ 464:\n/***/ function(module, exports, __webpack_require__) {\n\n\t\n\tmodule.exports = __webpack_require__(465);\n\n\n/***/ },\n\n/***/ 465:\n/***/ function(module, exports, __webpack_require__) {\n\n\t\n\tmodule.exports = __webpack_require__(466);\n\t\n\t/**\n\t * Exports parser\n\t *\n\t * @api public\n\t *\n\t */\n\tmodule.exports.parser = __webpack_require__(473);\n\n\n/***/ },\n\n/***/ 466:\n/***/ function(module, exports, __webpack_require__) {\n\n\t/* WEBPACK VAR INJECTION */(function(global) {/**\n\t * Module dependencies.\n\t */\n\t\n\tvar transports = __webpack_require__(467);\n\tvar Emitter = __webpack_require__(482);\n\tvar debug = __webpack_require__(486)('engine.io-client:socket');\n\tvar index = __webpack_require__(491);\n\tvar parser = __webpack_require__(473);\n\tvar parseuri = __webpack_require__(448);\n\tvar parsejson = __webpack_require__(492);\n\tvar parseqs = __webpack_require__(483);\n\t\n\t/**\n\t * Module exports.\n\t */\n\t\n\tmodule.exports = Socket;\n\t\n\t/**\n\t * Socket constructor.\n\t *\n\t * @param {String|Object} uri or options\n\t * @param {Object} options\n\t * @api public\n\t */\n\t\n\tfunction Socket (uri, opts) {\n\t  if (!(this instanceof Socket)) return new Socket(uri, opts);\n\t\n\t  opts = opts || {};\n\t\n\t  if (uri && 'object' === typeof uri) {\n\t    opts = uri;\n\t    uri = null;\n\t  }\n\t\n\t  if (uri) {\n\t    uri = parseuri(uri);\n\t    opts.hostname = uri.host;\n\t    opts.secure = uri.protocol === 'https' || uri.protocol === 'wss';\n\t    opts.port = uri.port;\n\t    if (uri.query) opts.query = uri.query;\n\t  } else if (opts.host) {\n\t    opts.hostname = parseuri(opts.host).host;\n\t  }\n\t\n\t  this.secure = null != opts.secure ? opts.secure\n\t    : (global.location && 'https:' === location.protocol);\n\t\n\t  if (opts.hostname && !opts.port) {\n\t    // if no port is specified manually, use the protocol default\n\t    opts.port = this.secure ? '443' : '80';\n\t  }\n\t\n\t  this.agent = opts.agent || false;\n\t  this.hostname = opts.hostname ||\n\t    (global.location ? location.hostname : 'localhost');\n\t  this.port = opts.port || (global.location && location.port\n\t      ? location.port\n\t      : (this.secure ? 443 : 80));\n\t  this.query = opts.query || {};\n\t  if ('string' === typeof this.query) this.query = parseqs.decode(this.query);\n\t  this.upgrade = false !== opts.upgrade;\n\t  this.path = (opts.path || '/engine.io').replace(/\\/$/, '') + '/';\n\t  this.forceJSONP = !!opts.forceJSONP;\n\t  this.jsonp = false !== opts.jsonp;\n\t  this.forceBase64 = !!opts.forceBase64;\n\t  this.enablesXDR = !!opts.enablesXDR;\n\t  this.timestampParam = opts.timestampParam || 't';\n\t  this.timestampRequests = opts.timestampRequests;\n\t  this.transports = opts.transports || ['polling', 'websocket'];\n\t  this.readyState = '';\n\t  this.writeBuffer = [];\n\t  this.prevBufferLen = 0;\n\t  this.policyPort = opts.policyPort || 843;\n\t  this.rememberUpgrade = opts.rememberUpgrade || false;\n\t  this.binaryType = null;\n\t  this.onlyBinaryUpgrades = opts.onlyBinaryUpgrades;\n\t  this.perMessageDeflate = false !== opts.perMessageDeflate ? (opts.perMessageDeflate || {}) : false;\n\t\n\t  if (true === this.perMessageDeflate) this.perMessageDeflate = {};\n\t  if (this.perMessageDeflate && null == this.perMessageDeflate.threshold) {\n\t    this.perMessageDeflate.threshold = 1024;\n\t  }\n\t\n\t  // SSL options for Node.js client\n\t  this.pfx = opts.pfx || null;\n\t  this.key = opts.key || null;\n\t  this.passphrase = opts.passphrase || null;\n\t  this.cert = opts.cert || null;\n\t  this.ca = opts.ca || null;\n\t  this.ciphers = opts.ciphers || null;\n\t  this.rejectUnauthorized = opts.rejectUnauthorized === undefined ? null : opts.rejectUnauthorized;\n\t  this.forceNode = !!opts.forceNode;\n\t\n\t  // other options for Node.js client\n\t  var freeGlobal = typeof global === 'object' && global;\n\t  if (freeGlobal.global === freeGlobal) {\n\t    if (opts.extraHeaders && Object.keys(opts.extraHeaders).length > 0) {\n\t      this.extraHeaders = opts.extraHeaders;\n\t    }\n\t\n\t    if (opts.localAddress) {\n\t      this.localAddress = opts.localAddress;\n\t    }\n\t  }\n\t\n\t  // set on handshake\n\t  this.id = null;\n\t  this.upgrades = null;\n\t  this.pingInterval = null;\n\t  this.pingTimeout = null;\n\t\n\t  // set on heartbeat\n\t  this.pingIntervalTimer = null;\n\t  this.pingTimeoutTimer = null;\n\t\n\t  this.open();\n\t}\n\t\n\tSocket.priorWebsocketSuccess = false;\n\t\n\t/**\n\t * Mix in `Emitter`.\n\t */\n\t\n\tEmitter(Socket.prototype);\n\t\n\t/**\n\t * Protocol version.\n\t *\n\t * @api public\n\t */\n\t\n\tSocket.protocol = parser.protocol; // this is an int\n\t\n\t/**\n\t * Expose deps for legacy compatibility\n\t * and standalone browser access.\n\t */\n\t\n\tSocket.Socket = Socket;\n\tSocket.Transport = __webpack_require__(472);\n\tSocket.transports = __webpack_require__(467);\n\tSocket.parser = __webpack_require__(473);\n\t\n\t/**\n\t * Creates transport of the given type.\n\t *\n\t * @param {String} transport name\n\t * @return {Transport}\n\t * @api private\n\t */\n\t\n\tSocket.prototype.createTransport = function (name) {\n\t  debug('creating transport \"%s\"', name);\n\t  var query = clone(this.query);\n\t\n\t  // append engine.io protocol identifier\n\t  query.EIO = parser.protocol;\n\t\n\t  // transport name\n\t  query.transport = name;\n\t\n\t  // session id if we already have one\n\t  if (this.id) query.sid = this.id;\n\t\n\t  var transport = new transports[name]({\n\t    agent: this.agent,\n\t    hostname: this.hostname,\n\t    port: this.port,\n\t    secure: this.secure,\n\t    path: this.path,\n\t    query: query,\n\t    forceJSONP: this.forceJSONP,\n\t    jsonp: this.jsonp,\n\t    forceBase64: this.forceBase64,\n\t    enablesXDR: this.enablesXDR,\n\t    timestampRequests: this.timestampRequests,\n\t    timestampParam: this.timestampParam,\n\t    policyPort: this.policyPort,\n\t    socket: this,\n\t    pfx: this.pfx,\n\t    key: this.key,\n\t    passphrase: this.passphrase,\n\t    cert: this.cert,\n\t    ca: this.ca,\n\t    ciphers: this.ciphers,\n\t    rejectUnauthorized: this.rejectUnauthorized,\n\t    perMessageDeflate: this.perMessageDeflate,\n\t    extraHeaders: this.extraHeaders,\n\t    forceNode: this.forceNode,\n\t    localAddress: this.localAddress\n\t  });\n\t\n\t  return transport;\n\t};\n\t\n\tfunction clone (obj) {\n\t  var o = {};\n\t  for (var i in obj) {\n\t    if (obj.hasOwnProperty(i)) {\n\t      o[i] = obj[i];\n\t    }\n\t  }\n\t  return o;\n\t}\n\t\n\t/**\n\t * Initializes transport to use and starts probe.\n\t *\n\t * @api private\n\t */\n\tSocket.prototype.open = function () {\n\t  var transport;\n\t  if (this.rememberUpgrade && Socket.priorWebsocketSuccess && this.transports.indexOf('websocket') !== -1) {\n\t    transport = 'websocket';\n\t  } else if (0 === this.transports.length) {\n\t    // Emit error on next tick so it can be listened to\n\t    var self = this;\n\t    setTimeout(function () {\n\t      self.emit('error', 'No transports available');\n\t    }, 0);\n\t    return;\n\t  } else {\n\t    transport = this.transports[0];\n\t  }\n\t  this.readyState = 'opening';\n\t\n\t  // Retry with the next transport if the transport is disabled (jsonp: false)\n\t  try {\n\t    transport = this.createTransport(transport);\n\t  } catch (e) {\n\t    this.transports.shift();\n\t    this.open();\n\t    return;\n\t  }\n\t\n\t  transport.open();\n\t  this.setTransport(transport);\n\t};\n\t\n\t/**\n\t * Sets the current transport. Disables the existing one (if any).\n\t *\n\t * @api private\n\t */\n\t\n\tSocket.prototype.setTransport = function (transport) {\n\t  debug('setting transport %s', transport.name);\n\t  var self = this;\n\t\n\t  if (this.transport) {\n\t    debug('clearing existing transport %s', this.transport.name);\n\t    this.transport.removeAllListeners();\n\t  }\n\t\n\t  // set up transport\n\t  this.transport = transport;\n\t\n\t  // set up transport listeners\n\t  transport\n\t  .on('drain', function () {\n\t    self.onDrain();\n\t  })\n\t  .on('packet', function (packet) {\n\t    self.onPacket(packet);\n\t  })\n\t  .on('error', function (e) {\n\t    self.onError(e);\n\t  })\n\t  .on('close', function () {\n\t    self.onClose('transport close');\n\t  });\n\t};\n\t\n\t/**\n\t * Probes a transport.\n\t *\n\t * @param {String} transport name\n\t * @api private\n\t */\n\t\n\tSocket.prototype.probe = function (name) {\n\t  debug('probing transport \"%s\"', name);\n\t  var transport = this.createTransport(name, { probe: 1 });\n\t  var failed = false;\n\t  var self = this;\n\t\n\t  Socket.priorWebsocketSuccess = false;\n\t\n\t  function onTransportOpen () {\n\t    if (self.onlyBinaryUpgrades) {\n\t      var upgradeLosesBinary = !this.supportsBinary && self.transport.supportsBinary;\n\t      failed = failed || upgradeLosesBinary;\n\t    }\n\t    if (failed) return;\n\t\n\t    debug('probe transport \"%s\" opened', name);\n\t    transport.send([{ type: 'ping', data: 'probe' }]);\n\t    transport.once('packet', function (msg) {\n\t      if (failed) return;\n\t      if ('pong' === msg.type && 'probe' === msg.data) {\n\t        debug('probe transport \"%s\" pong', name);\n\t        self.upgrading = true;\n\t        self.emit('upgrading', transport);\n\t        if (!transport) return;\n\t        Socket.priorWebsocketSuccess = 'websocket' === transport.name;\n\t\n\t        debug('pausing current transport \"%s\"', self.transport.name);\n\t        self.transport.pause(function () {\n\t          if (failed) return;\n\t          if ('closed' === self.readyState) return;\n\t          debug('changing transport and sending upgrade packet');\n\t\n\t          cleanup();\n\t\n\t          self.setTransport(transport);\n\t          transport.send([{ type: 'upgrade' }]);\n\t          self.emit('upgrade', transport);\n\t          transport = null;\n\t          self.upgrading = false;\n\t          self.flush();\n\t        });\n\t      } else {\n\t        debug('probe transport \"%s\" failed', name);\n\t        var err = new Error('probe error');\n\t        err.transport = transport.name;\n\t        self.emit('upgradeError', err);\n\t      }\n\t    });\n\t  }\n\t\n\t  function freezeTransport () {\n\t    if (failed) return;\n\t\n\t    // Any callback called by transport should be ignored since now\n\t    failed = true;\n\t\n\t    cleanup();\n\t\n\t    transport.close();\n\t    transport = null;\n\t  }\n\t\n\t  // Handle any error that happens while probing\n\t  function onerror (err) {\n\t    var error = new Error('probe error: ' + err);\n\t    error.transport = transport.name;\n\t\n\t    freezeTransport();\n\t\n\t    debug('probe transport \"%s\" failed because of error: %s', name, err);\n\t\n\t    self.emit('upgradeError', error);\n\t  }\n\t\n\t  function onTransportClose () {\n\t    onerror('transport closed');\n\t  }\n\t\n\t  // When the socket is closed while we're probing\n\t  function onclose () {\n\t    onerror('socket closed');\n\t  }\n\t\n\t  // When the socket is upgraded while we're probing\n\t  function onupgrade (to) {\n\t    if (transport && to.name !== transport.name) {\n\t      debug('\"%s\" works - aborting \"%s\"', to.name, transport.name);\n\t      freezeTransport();\n\t    }\n\t  }\n\t\n\t  // Remove all listeners on the transport and on self\n\t  function cleanup () {\n\t    transport.removeListener('open', onTransportOpen);\n\t    transport.removeListener('error', onerror);\n\t    transport.removeListener('close', onTransportClose);\n\t    self.removeListener('close', onclose);\n\t    self.removeListener('upgrading', onupgrade);\n\t  }\n\t\n\t  transport.once('open', onTransportOpen);\n\t  transport.once('error', onerror);\n\t  transport.once('close', onTransportClose);\n\t\n\t  this.once('close', onclose);\n\t  this.once('upgrading', onupgrade);\n\t\n\t  transport.open();\n\t};\n\t\n\t/**\n\t * Called when connection is deemed open.\n\t *\n\t * @api public\n\t */\n\t\n\tSocket.prototype.onOpen = function () {\n\t  debug('socket open');\n\t  this.readyState = 'open';\n\t  Socket.priorWebsocketSuccess = 'websocket' === this.transport.name;\n\t  this.emit('open');\n\t  this.flush();\n\t\n\t  // we check for `readyState` in case an `open`\n\t  // listener already closed the socket\n\t  if ('open' === this.readyState && this.upgrade && this.transport.pause) {\n\t    debug('starting upgrade probes');\n\t    for (var i = 0, l = this.upgrades.length; i < l; i++) {\n\t      this.probe(this.upgrades[i]);\n\t    }\n\t  }\n\t};\n\t\n\t/**\n\t * Handles a packet.\n\t *\n\t * @api private\n\t */\n\t\n\tSocket.prototype.onPacket = function (packet) {\n\t  if ('opening' === this.readyState || 'open' === this.readyState ||\n\t      'closing' === this.readyState) {\n\t    debug('socket receive: type \"%s\", data \"%s\"', packet.type, packet.data);\n\t\n\t    this.emit('packet', packet);\n\t\n\t    // Socket is live - any packet counts\n\t    this.emit('heartbeat');\n\t\n\t    switch (packet.type) {\n\t      case 'open':\n\t        this.onHandshake(parsejson(packet.data));\n\t        break;\n\t\n\t      case 'pong':\n\t        this.setPing();\n\t        this.emit('pong');\n\t        break;\n\t\n\t      case 'error':\n\t        var err = new Error('server error');\n\t        err.code = packet.data;\n\t        this.onError(err);\n\t        break;\n\t\n\t      case 'message':\n\t        this.emit('data', packet.data);\n\t        this.emit('message', packet.data);\n\t        break;\n\t    }\n\t  } else {\n\t    debug('packet received with socket readyState \"%s\"', this.readyState);\n\t  }\n\t};\n\t\n\t/**\n\t * Called upon handshake completion.\n\t *\n\t * @param {Object} handshake obj\n\t * @api private\n\t */\n\t\n\tSocket.prototype.onHandshake = function (data) {\n\t  this.emit('handshake', data);\n\t  this.id = data.sid;\n\t  this.transport.query.sid = data.sid;\n\t  this.upgrades = this.filterUpgrades(data.upgrades);\n\t  this.pingInterval = data.pingInterval;\n\t  this.pingTimeout = data.pingTimeout;\n\t  this.onOpen();\n\t  // In case open handler closes socket\n\t  if ('closed' === this.readyState) return;\n\t  this.setPing();\n\t\n\t  // Prolong liveness of socket on heartbeat\n\t  this.removeListener('heartbeat', this.onHeartbeat);\n\t  this.on('heartbeat', this.onHeartbeat);\n\t};\n\t\n\t/**\n\t * Resets ping timeout.\n\t *\n\t * @api private\n\t */\n\t\n\tSocket.prototype.onHeartbeat = function (timeout) {\n\t  clearTimeout(this.pingTimeoutTimer);\n\t  var self = this;\n\t  self.pingTimeoutTimer = setTimeout(function () {\n\t    if ('closed' === self.readyState) return;\n\t    self.onClose('ping timeout');\n\t  }, timeout || (self.pingInterval + self.pingTimeout));\n\t};\n\t\n\t/**\n\t * Pings server every `this.pingInterval` and expects response\n\t * within `this.pingTimeout` or closes connection.\n\t *\n\t * @api private\n\t */\n\t\n\tSocket.prototype.setPing = function () {\n\t  var self = this;\n\t  clearTimeout(self.pingIntervalTimer);\n\t  self.pingIntervalTimer = setTimeout(function () {\n\t    debug('writing ping packet - expecting pong within %sms', self.pingTimeout);\n\t    self.ping();\n\t    self.onHeartbeat(self.pingTimeout);\n\t  }, self.pingInterval);\n\t};\n\t\n\t/**\n\t* Sends a ping packet.\n\t*\n\t* @api private\n\t*/\n\t\n\tSocket.prototype.ping = function () {\n\t  var self = this;\n\t  this.sendPacket('ping', function () {\n\t    self.emit('ping');\n\t  });\n\t};\n\t\n\t/**\n\t * Called on `drain` event\n\t *\n\t * @api private\n\t */\n\t\n\tSocket.prototype.onDrain = function () {\n\t  this.writeBuffer.splice(0, this.prevBufferLen);\n\t\n\t  // setting prevBufferLen = 0 is very important\n\t  // for example, when upgrading, upgrade packet is sent over,\n\t  // and a nonzero prevBufferLen could cause problems on `drain`\n\t  this.prevBufferLen = 0;\n\t\n\t  if (0 === this.writeBuffer.length) {\n\t    this.emit('drain');\n\t  } else {\n\t    this.flush();\n\t  }\n\t};\n\t\n\t/**\n\t * Flush write buffers.\n\t *\n\t * @api private\n\t */\n\t\n\tSocket.prototype.flush = function () {\n\t  if ('closed' !== this.readyState && this.transport.writable &&\n\t    !this.upgrading && this.writeBuffer.length) {\n\t    debug('flushing %d packets in socket', this.writeBuffer.length);\n\t    this.transport.send(this.writeBuffer);\n\t    // keep track of current length of writeBuffer\n\t    // splice writeBuffer and callbackBuffer on `drain`\n\t    this.prevBufferLen = this.writeBuffer.length;\n\t    this.emit('flush');\n\t  }\n\t};\n\t\n\t/**\n\t * Sends a message.\n\t *\n\t * @param {String} message.\n\t * @param {Function} callback function.\n\t * @param {Object} options.\n\t * @return {Socket} for chaining.\n\t * @api public\n\t */\n\t\n\tSocket.prototype.write =\n\tSocket.prototype.send = function (msg, options, fn) {\n\t  this.sendPacket('message', msg, options, fn);\n\t  return this;\n\t};\n\t\n\t/**\n\t * Sends a packet.\n\t *\n\t * @param {String} packet type.\n\t * @param {String} data.\n\t * @param {Object} options.\n\t * @param {Function} callback function.\n\t * @api private\n\t */\n\t\n\tSocket.prototype.sendPacket = function (type, data, options, fn) {\n\t  if ('function' === typeof data) {\n\t    fn = data;\n\t    data = undefined;\n\t  }\n\t\n\t  if ('function' === typeof options) {\n\t    fn = options;\n\t    options = null;\n\t  }\n\t\n\t  if ('closing' === this.readyState || 'closed' === this.readyState) {\n\t    return;\n\t  }\n\t\n\t  options = options || {};\n\t  options.compress = false !== options.compress;\n\t\n\t  var packet = {\n\t    type: type,\n\t    data: data,\n\t    options: options\n\t  };\n\t  this.emit('packetCreate', packet);\n\t  this.writeBuffer.push(packet);\n\t  if (fn) this.once('flush', fn);\n\t  this.flush();\n\t};\n\t\n\t/**\n\t * Closes the connection.\n\t *\n\t * @api private\n\t */\n\t\n\tSocket.prototype.close = function () {\n\t  if ('opening' === this.readyState || 'open' === this.readyState) {\n\t    this.readyState = 'closing';\n\t\n\t    var self = this;\n\t\n\t    if (this.writeBuffer.length) {\n\t      this.once('drain', function () {\n\t        if (this.upgrading) {\n\t          waitForUpgrade();\n\t        } else {\n\t          close();\n\t        }\n\t      });\n\t    } else if (this.upgrading) {\n\t      waitForUpgrade();\n\t    } else {\n\t      close();\n\t    }\n\t  }\n\t\n\t  function close () {\n\t    self.onClose('forced close');\n\t    debug('socket closing - telling transport to close');\n\t    self.transport.close();\n\t  }\n\t\n\t  function cleanupAndClose () {\n\t    self.removeListener('upgrade', cleanupAndClose);\n\t    self.removeListener('upgradeError', cleanupAndClose);\n\t    close();\n\t  }\n\t\n\t  function waitForUpgrade () {\n\t    // wait for upgrade to finish since we can't send packets while pausing a transport\n\t    self.once('upgrade', cleanupAndClose);\n\t    self.once('upgradeError', cleanupAndClose);\n\t  }\n\t\n\t  return this;\n\t};\n\t\n\t/**\n\t * Called upon transport error\n\t *\n\t * @api private\n\t */\n\t\n\tSocket.prototype.onError = function (err) {\n\t  debug('socket error %j', err);\n\t  Socket.priorWebsocketSuccess = false;\n\t  this.emit('error', err);\n\t  this.onClose('transport error', err);\n\t};\n\t\n\t/**\n\t * Called upon transport close.\n\t *\n\t * @api private\n\t */\n\t\n\tSocket.prototype.onClose = function (reason, desc) {\n\t  if ('opening' === this.readyState || 'open' === this.readyState || 'closing' === this.readyState) {\n\t    debug('socket close with reason: \"%s\"', reason);\n\t    var self = this;\n\t\n\t    // clear timers\n\t    clearTimeout(this.pingIntervalTimer);\n\t    clearTimeout(this.pingTimeoutTimer);\n\t\n\t    // stop event from firing again for transport\n\t    this.transport.removeAllListeners('close');\n\t\n\t    // ensure transport won't stay open\n\t    this.transport.close();\n\t\n\t    // ignore further transport communication\n\t    this.transport.removeAllListeners();\n\t\n\t    // set ready state\n\t    this.readyState = 'closed';\n\t\n\t    // clear session id\n\t    this.id = null;\n\t\n\t    // emit close event\n\t    this.emit('close', reason, desc);\n\t\n\t    // clean buffers after, so users can still\n\t    // grab the buffers on `close` event\n\t    self.writeBuffer = [];\n\t    self.prevBufferLen = 0;\n\t  }\n\t};\n\t\n\t/**\n\t * Filters upgrades, returning only those matching client transports.\n\t *\n\t * @param {Array} server upgrades\n\t * @api private\n\t *\n\t */\n\t\n\tSocket.prototype.filterUpgrades = function (upgrades) {\n\t  var filteredUpgrades = [];\n\t  for (var i = 0, j = upgrades.length; i < j; i++) {\n\t    if (~index(this.transports, upgrades[i])) filteredUpgrades.push(upgrades[i]);\n\t  }\n\t  return filteredUpgrades;\n\t};\n\t\n\t/* WEBPACK VAR INJECTION */}.call(exports, (function() { return this; }())))\n\n/***/ },\n\n/***/ 467:\n/***/ function(module, exports, __webpack_require__) {\n\n\t/* WEBPACK VAR INJECTION */(function(global) {/**\n\t * Module dependencies\n\t */\n\t\n\tvar XMLHttpRequest = __webpack_require__(468);\n\tvar XHR = __webpack_require__(470);\n\tvar JSONP = __webpack_require__(488);\n\tvar websocket = __webpack_require__(489);\n\t\n\t/**\n\t * Export transports.\n\t */\n\t\n\texports.polling = polling;\n\texports.websocket = websocket;\n\t\n\t/**\n\t * Polling transport polymorphic constructor.\n\t * Decides on xhr vs jsonp based on feature detection.\n\t *\n\t * @api private\n\t */\n\t\n\tfunction polling (opts) {\n\t  var xhr;\n\t  var xd = false;\n\t  var xs = false;\n\t  var jsonp = false !== opts.jsonp;\n\t\n\t  if (global.location) {\n\t    var isSSL = 'https:' === location.protocol;\n\t    var port = location.port;\n\t\n\t    // some user agents have empty `location.port`\n\t    if (!port) {\n\t      port = isSSL ? 443 : 80;\n\t    }\n\t\n\t    xd = opts.hostname !== location.hostname || port !== opts.port;\n\t    xs = opts.secure !== isSSL;\n\t  }\n\t\n\t  opts.xdomain = xd;\n\t  opts.xscheme = xs;\n\t  xhr = new XMLHttpRequest(opts);\n\t\n\t  if ('open' in xhr && !opts.forceJSONP) {\n\t    return new XHR(opts);\n\t  } else {\n\t    if (!jsonp) throw new Error('JSONP disabled');\n\t    return new JSONP(opts);\n\t  }\n\t}\n\t\n\t/* WEBPACK VAR INJECTION */}.call(exports, (function() { return this; }())))\n\n/***/ },\n\n/***/ 468:\n/***/ function(module, exports, __webpack_require__) {\n\n\t/* WEBPACK VAR INJECTION */(function(global) {// browser shim for xmlhttprequest module\n\t\n\tvar hasCORS = __webpack_require__(469);\n\t\n\tmodule.exports = function (opts) {\n\t  var xdomain = opts.xdomain;\n\t\n\t  // scheme must be same when usign XDomainRequest\n\t  // http://blogs.msdn.com/b/ieinternals/archive/2010/05/13/xdomainrequest-restrictions-limitations-and-workarounds.aspx\n\t  var xscheme = opts.xscheme;\n\t\n\t  // XDomainRequest has a flow of not sending cookie, therefore it should be disabled as a default.\n\t  // https://github.com/Automattic/engine.io-client/pull/217\n\t  var enablesXDR = opts.enablesXDR;\n\t\n\t  // XMLHttpRequest can be disabled on IE\n\t  try {\n\t    if ('undefined' !== typeof XMLHttpRequest && (!xdomain || hasCORS)) {\n\t      return new XMLHttpRequest();\n\t    }\n\t  } catch (e) { }\n\t\n\t  // Use XDomainRequest for IE8 if enablesXDR is true\n\t  // because loading bar keeps flashing when using jsonp-polling\n\t  // https://github.com/yujiosaka/socke.io-ie8-loading-example\n\t  try {\n\t    if ('undefined' !== typeof XDomainRequest && !xscheme && enablesXDR) {\n\t      return new XDomainRequest();\n\t    }\n\t  } catch (e) { }\n\t\n\t  if (!xdomain) {\n\t    try {\n\t      return new global[['Active'].concat('Object').join('X')]('Microsoft.XMLHTTP');\n\t    } catch (e) { }\n\t  }\n\t};\n\t\n\t/* WEBPACK VAR INJECTION */}.call(exports, (function() { return this; }())))\n\n/***/ },\n\n/***/ 469:\n/***/ function(module, exports) {\n\n\t\n\t/**\n\t * Module exports.\n\t *\n\t * Logic borrowed from Modernizr:\n\t *\n\t *   - https://github.com/Modernizr/Modernizr/blob/master/feature-detects/cors.js\n\t */\n\t\n\ttry {\n\t  module.exports = typeof XMLHttpRequest !== 'undefined' &&\n\t    'withCredentials' in new XMLHttpRequest();\n\t} catch (err) {\n\t  // if XMLHttp support is disabled in IE then it will throw\n\t  // when trying to create\n\t  module.exports = false;\n\t}\n\n\n/***/ },\n\n/***/ 470:\n/***/ function(module, exports, __webpack_require__) {\n\n\t/* WEBPACK VAR INJECTION */(function(global) {/**\n\t * Module requirements.\n\t */\n\t\n\tvar XMLHttpRequest = __webpack_require__(468);\n\tvar Polling = __webpack_require__(471);\n\tvar Emitter = __webpack_require__(482);\n\tvar inherit = __webpack_require__(484);\n\tvar debug = __webpack_require__(486)('engine.io-client:polling-xhr');\n\t\n\t/**\n\t * Module exports.\n\t */\n\t\n\tmodule.exports = XHR;\n\tmodule.exports.Request = Request;\n\t\n\t/**\n\t * Empty function\n\t */\n\t\n\tfunction empty () {}\n\t\n\t/**\n\t * XHR Polling constructor.\n\t *\n\t * @param {Object} opts\n\t * @api public\n\t */\n\t\n\tfunction XHR (opts) {\n\t  Polling.call(this, opts);\n\t  this.requestTimeout = opts.requestTimeout;\n\t\n\t  if (global.location) {\n\t    var isSSL = 'https:' === location.protocol;\n\t    var port = location.port;\n\t\n\t    // some user agents have empty `location.port`\n\t    if (!port) {\n\t      port = isSSL ? 443 : 80;\n\t    }\n\t\n\t    this.xd = opts.hostname !== global.location.hostname ||\n\t      port !== opts.port;\n\t    this.xs = opts.secure !== isSSL;\n\t  } else {\n\t    this.extraHeaders = opts.extraHeaders;\n\t  }\n\t}\n\t\n\t/**\n\t * Inherits from Polling.\n\t */\n\t\n\tinherit(XHR, Polling);\n\t\n\t/**\n\t * XHR supports binary\n\t */\n\t\n\tXHR.prototype.supportsBinary = true;\n\t\n\t/**\n\t * Creates a request.\n\t *\n\t * @param {String} method\n\t * @api private\n\t */\n\t\n\tXHR.prototype.request = function (opts) {\n\t  opts = opts || {};\n\t  opts.uri = this.uri();\n\t  opts.xd = this.xd;\n\t  opts.xs = this.xs;\n\t  opts.agent = this.agent || false;\n\t  opts.supportsBinary = this.supportsBinary;\n\t  opts.enablesXDR = this.enablesXDR;\n\t\n\t  // SSL options for Node.js client\n\t  opts.pfx = this.pfx;\n\t  opts.key = this.key;\n\t  opts.passphrase = this.passphrase;\n\t  opts.cert = this.cert;\n\t  opts.ca = this.ca;\n\t  opts.ciphers = this.ciphers;\n\t  opts.rejectUnauthorized = this.rejectUnauthorized;\n\t  opts.requestTimeout = this.requestTimeout;\n\t\n\t  // other options for Node.js client\n\t  opts.extraHeaders = this.extraHeaders;\n\t\n\t  return new Request(opts);\n\t};\n\t\n\t/**\n\t * Sends data.\n\t *\n\t * @param {String} data to send.\n\t * @param {Function} called upon flush.\n\t * @api private\n\t */\n\t\n\tXHR.prototype.doWrite = function (data, fn) {\n\t  var isBinary = typeof data !== 'string' && data !== undefined;\n\t  var req = this.request({ method: 'POST', data: data, isBinary: isBinary });\n\t  var self = this;\n\t  req.on('success', fn);\n\t  req.on('error', function (err) {\n\t    self.onError('xhr post error', err);\n\t  });\n\t  this.sendXhr = req;\n\t};\n\t\n\t/**\n\t * Starts a poll cycle.\n\t *\n\t * @api private\n\t */\n\t\n\tXHR.prototype.doPoll = function () {\n\t  debug('xhr poll');\n\t  var req = this.request();\n\t  var self = this;\n\t  req.on('data', function (data) {\n\t    self.onData(data);\n\t  });\n\t  req.on('error', function (err) {\n\t    self.onError('xhr poll error', err);\n\t  });\n\t  this.pollXhr = req;\n\t};\n\t\n\t/**\n\t * Request constructor\n\t *\n\t * @param {Object} options\n\t * @api public\n\t */\n\t\n\tfunction Request (opts) {\n\t  this.method = opts.method || 'GET';\n\t  this.uri = opts.uri;\n\t  this.xd = !!opts.xd;\n\t  this.xs = !!opts.xs;\n\t  this.async = false !== opts.async;\n\t  this.data = undefined !== opts.data ? opts.data : null;\n\t  this.agent = opts.agent;\n\t  this.isBinary = opts.isBinary;\n\t  this.supportsBinary = opts.supportsBinary;\n\t  this.enablesXDR = opts.enablesXDR;\n\t  this.requestTimeout = opts.requestTimeout;\n\t\n\t  // SSL options for Node.js client\n\t  this.pfx = opts.pfx;\n\t  this.key = opts.key;\n\t  this.passphrase = opts.passphrase;\n\t  this.cert = opts.cert;\n\t  this.ca = opts.ca;\n\t  this.ciphers = opts.ciphers;\n\t  this.rejectUnauthorized = opts.rejectUnauthorized;\n\t\n\t  // other options for Node.js client\n\t  this.extraHeaders = opts.extraHeaders;\n\t\n\t  this.create();\n\t}\n\t\n\t/**\n\t * Mix in `Emitter`.\n\t */\n\t\n\tEmitter(Request.prototype);\n\t\n\t/**\n\t * Creates the XHR object and sends the request.\n\t *\n\t * @api private\n\t */\n\t\n\tRequest.prototype.create = function () {\n\t  var opts = { agent: this.agent, xdomain: this.xd, xscheme: this.xs, enablesXDR: this.enablesXDR };\n\t\n\t  // SSL options for Node.js client\n\t  opts.pfx = this.pfx;\n\t  opts.key = this.key;\n\t  opts.passphrase = this.passphrase;\n\t  opts.cert = this.cert;\n\t  opts.ca = this.ca;\n\t  opts.ciphers = this.ciphers;\n\t  opts.rejectUnauthorized = this.rejectUnauthorized;\n\t\n\t  var xhr = this.xhr = new XMLHttpRequest(opts);\n\t  var self = this;\n\t\n\t  try {\n\t    debug('xhr open %s: %s', this.method, this.uri);\n\t    xhr.open(this.method, this.uri, this.async);\n\t    try {\n\t      if (this.extraHeaders) {\n\t        xhr.setDisableHeaderCheck(true);\n\t        for (var i in this.extraHeaders) {\n\t          if (this.extraHeaders.hasOwnProperty(i)) {\n\t            xhr.setRequestHeader(i, this.extraHeaders[i]);\n\t          }\n\t        }\n\t      }\n\t    } catch (e) {}\n\t    if (this.supportsBinary) {\n\t      // This has to be done after open because Firefox is stupid\n\t      // http://stackoverflow.com/questions/13216903/get-binary-data-with-xmlhttprequest-in-a-firefox-extension\n\t      xhr.responseType = 'arraybuffer';\n\t    }\n\t\n\t    if ('POST' === this.method) {\n\t      try {\n\t        if (this.isBinary) {\n\t          xhr.setRequestHeader('Content-type', 'application/octet-stream');\n\t        } else {\n\t          xhr.setRequestHeader('Content-type', 'text/plain;charset=UTF-8');\n\t        }\n\t      } catch (e) {}\n\t    }\n\t\n\t    try {\n\t      xhr.setRequestHeader('Accept', '*/*');\n\t    } catch (e) {}\n\t\n\t    // ie6 check\n\t    if ('withCredentials' in xhr) {\n\t      xhr.withCredentials = true;\n\t    }\n\t\n\t    if (this.requestTimeout) {\n\t      xhr.timeout = this.requestTimeout;\n\t    }\n\t\n\t    if (this.hasXDR()) {\n\t      xhr.onload = function () {\n\t        self.onLoad();\n\t      };\n\t      xhr.onerror = function () {\n\t        self.onError(xhr.responseText);\n\t      };\n\t    } else {\n\t      xhr.onreadystatechange = function () {\n\t        if (4 !== xhr.readyState) return;\n\t        if (200 === xhr.status || 1223 === xhr.status) {\n\t          self.onLoad();\n\t        } else {\n\t          // make sure the `error` event handler that's user-set\n\t          // does not throw in the same tick and gets caught here\n\t          setTimeout(function () {\n\t            self.onError(xhr.status);\n\t          }, 0);\n\t        }\n\t      };\n\t    }\n\t\n\t    debug('xhr data %s', this.data);\n\t    xhr.send(this.data);\n\t  } catch (e) {\n\t    // Need to defer since .create() is called directly fhrom the constructor\n\t    // and thus the 'error' event can only be only bound *after* this exception\n\t    // occurs.  Therefore, also, we cannot throw here at all.\n\t    setTimeout(function () {\n\t      self.onError(e);\n\t    }, 0);\n\t    return;\n\t  }\n\t\n\t  if (global.document) {\n\t    this.index = Request.requestsCount++;\n\t    Request.requests[this.index] = this;\n\t  }\n\t};\n\t\n\t/**\n\t * Called upon successful response.\n\t *\n\t * @api private\n\t */\n\t\n\tRequest.prototype.onSuccess = function () {\n\t  this.emit('success');\n\t  this.cleanup();\n\t};\n\t\n\t/**\n\t * Called if we have data.\n\t *\n\t * @api private\n\t */\n\t\n\tRequest.prototype.onData = function (data) {\n\t  this.emit('data', data);\n\t  this.onSuccess();\n\t};\n\t\n\t/**\n\t * Called upon error.\n\t *\n\t * @api private\n\t */\n\t\n\tRequest.prototype.onError = function (err) {\n\t  this.emit('error', err);\n\t  this.cleanup(true);\n\t};\n\t\n\t/**\n\t * Cleans up house.\n\t *\n\t * @api private\n\t */\n\t\n\tRequest.prototype.cleanup = function (fromError) {\n\t  if ('undefined' === typeof this.xhr || null === this.xhr) {\n\t    return;\n\t  }\n\t  // xmlhttprequest\n\t  if (this.hasXDR()) {\n\t    this.xhr.onload = this.xhr.onerror = empty;\n\t  } else {\n\t    this.xhr.onreadystatechange = empty;\n\t  }\n\t\n\t  if (fromError) {\n\t    try {\n\t      this.xhr.abort();\n\t    } catch (e) {}\n\t  }\n\t\n\t  if (global.document) {\n\t    delete Request.requests[this.index];\n\t  }\n\t\n\t  this.xhr = null;\n\t};\n\t\n\t/**\n\t * Called upon load.\n\t *\n\t * @api private\n\t */\n\t\n\tRequest.prototype.onLoad = function () {\n\t  var data;\n\t  try {\n\t    var contentType;\n\t    try {\n\t      contentType = this.xhr.getResponseHeader('Content-Type').split(';')[0];\n\t    } catch (e) {}\n\t    if (contentType === 'application/octet-stream') {\n\t      data = this.xhr.response || this.xhr.responseText;\n\t    } else {\n\t      if (!this.supportsBinary) {\n\t        data = this.xhr.responseText;\n\t      } else {\n\t        try {\n\t          data = String.fromCharCode.apply(null, new Uint8Array(this.xhr.response));\n\t        } catch (e) {\n\t          var ui8Arr = new Uint8Array(this.xhr.response);\n\t          var dataArray = [];\n\t          for (var idx = 0, length = ui8Arr.length; idx < length; idx++) {\n\t            dataArray.push(ui8Arr[idx]);\n\t          }\n\t\n\t          data = String.fromCharCode.apply(null, dataArray);\n\t        }\n\t      }\n\t    }\n\t  } catch (e) {\n\t    this.onError(e);\n\t  }\n\t  if (null != data) {\n\t    this.onData(data);\n\t  }\n\t};\n\t\n\t/**\n\t * Check if it has XDomainRequest.\n\t *\n\t * @api private\n\t */\n\t\n\tRequest.prototype.hasXDR = function () {\n\t  return 'undefined' !== typeof global.XDomainRequest && !this.xs && this.enablesXDR;\n\t};\n\t\n\t/**\n\t * Aborts the request.\n\t *\n\t * @api public\n\t */\n\t\n\tRequest.prototype.abort = function () {\n\t  this.cleanup();\n\t};\n\t\n\t/**\n\t * Aborts pending requests when unloading the window. This is needed to prevent\n\t * memory leaks (e.g. when using IE) and to ensure that no spurious error is\n\t * emitted.\n\t */\n\t\n\tRequest.requestsCount = 0;\n\tRequest.requests = {};\n\t\n\tif (global.document) {\n\t  if (global.attachEvent) {\n\t    global.attachEvent('onunload', unloadHandler);\n\t  } else if (global.addEventListener) {\n\t    global.addEventListener('beforeunload', unloadHandler, false);\n\t  }\n\t}\n\t\n\tfunction unloadHandler () {\n\t  for (var i in Request.requests) {\n\t    if (Request.requests.hasOwnProperty(i)) {\n\t      Request.requests[i].abort();\n\t    }\n\t  }\n\t}\n\t\n\t/* WEBPACK VAR INJECTION */}.call(exports, (function() { return this; }())))\n\n/***/ },\n\n/***/ 471:\n/***/ function(module, exports, __webpack_require__) {\n\n\t/**\n\t * Module dependencies.\n\t */\n\t\n\tvar Transport = __webpack_require__(472);\n\tvar parseqs = __webpack_require__(483);\n\tvar parser = __webpack_require__(473);\n\tvar inherit = __webpack_require__(484);\n\tvar yeast = __webpack_require__(485);\n\tvar debug = __webpack_require__(486)('engine.io-client:polling');\n\t\n\t/**\n\t * Module exports.\n\t */\n\t\n\tmodule.exports = Polling;\n\t\n\t/**\n\t * Is XHR2 supported?\n\t */\n\t\n\tvar hasXHR2 = (function () {\n\t  var XMLHttpRequest = __webpack_require__(468);\n\t  var xhr = new XMLHttpRequest({ xdomain: false });\n\t  return null != xhr.responseType;\n\t})();\n\t\n\t/**\n\t * Polling interface.\n\t *\n\t * @param {Object} opts\n\t * @api private\n\t */\n\t\n\tfunction Polling (opts) {\n\t  var forceBase64 = (opts && opts.forceBase64);\n\t  if (!hasXHR2 || forceBase64) {\n\t    this.supportsBinary = false;\n\t  }\n\t  Transport.call(this, opts);\n\t}\n\t\n\t/**\n\t * Inherits from Transport.\n\t */\n\t\n\tinherit(Polling, Transport);\n\t\n\t/**\n\t * Transport name.\n\t */\n\t\n\tPolling.prototype.name = 'polling';\n\t\n\t/**\n\t * Opens the socket (triggers polling). We write a PING message to determine\n\t * when the transport is open.\n\t *\n\t * @api private\n\t */\n\t\n\tPolling.prototype.doOpen = function () {\n\t  this.poll();\n\t};\n\t\n\t/**\n\t * Pauses polling.\n\t *\n\t * @param {Function} callback upon buffers are flushed and transport is paused\n\t * @api private\n\t */\n\t\n\tPolling.prototype.pause = function (onPause) {\n\t  var self = this;\n\t\n\t  this.readyState = 'pausing';\n\t\n\t  function pause () {\n\t    debug('paused');\n\t    self.readyState = 'paused';\n\t    onPause();\n\t  }\n\t\n\t  if (this.polling || !this.writable) {\n\t    var total = 0;\n\t\n\t    if (this.polling) {\n\t      debug('we are currently polling - waiting to pause');\n\t      total++;\n\t      this.once('pollComplete', function () {\n\t        debug('pre-pause polling complete');\n\t        --total || pause();\n\t      });\n\t    }\n\t\n\t    if (!this.writable) {\n\t      debug('we are currently writing - waiting to pause');\n\t      total++;\n\t      this.once('drain', function () {\n\t        debug('pre-pause writing complete');\n\t        --total || pause();\n\t      });\n\t    }\n\t  } else {\n\t    pause();\n\t  }\n\t};\n\t\n\t/**\n\t * Starts polling cycle.\n\t *\n\t * @api public\n\t */\n\t\n\tPolling.prototype.poll = function () {\n\t  debug('polling');\n\t  this.polling = true;\n\t  this.doPoll();\n\t  this.emit('poll');\n\t};\n\t\n\t/**\n\t * Overloads onData to detect payloads.\n\t *\n\t * @api private\n\t */\n\t\n\tPolling.prototype.onData = function (data) {\n\t  var self = this;\n\t  debug('polling got data %s', data);\n\t  var callback = function (packet, index, total) {\n\t    // if its the first message we consider the transport open\n\t    if ('opening' === self.readyState) {\n\t      self.onOpen();\n\t    }\n\t\n\t    // if its a close packet, we close the ongoing requests\n\t    if ('close' === packet.type) {\n\t      self.onClose();\n\t      return false;\n\t    }\n\t\n\t    // otherwise bypass onData and handle the message\n\t    self.onPacket(packet);\n\t  };\n\t\n\t  // decode payload\n\t  parser.decodePayload(data, this.socket.binaryType, callback);\n\t\n\t  // if an event did not trigger closing\n\t  if ('closed' !== this.readyState) {\n\t    // if we got data we're not polling\n\t    this.polling = false;\n\t    this.emit('pollComplete');\n\t\n\t    if ('open' === this.readyState) {\n\t      this.poll();\n\t    } else {\n\t      debug('ignoring poll - transport state \"%s\"', this.readyState);\n\t    }\n\t  }\n\t};\n\t\n\t/**\n\t * For polling, send a close packet.\n\t *\n\t * @api private\n\t */\n\t\n\tPolling.prototype.doClose = function () {\n\t  var self = this;\n\t\n\t  function close () {\n\t    debug('writing close packet');\n\t    self.write([{ type: 'close' }]);\n\t  }\n\t\n\t  if ('open' === this.readyState) {\n\t    debug('transport open - closing');\n\t    close();\n\t  } else {\n\t    // in case we're trying to close while\n\t    // handshaking is in progress (GH-164)\n\t    debug('transport not open - deferring close');\n\t    this.once('open', close);\n\t  }\n\t};\n\t\n\t/**\n\t * Writes a packets payload.\n\t *\n\t * @param {Array} data packets\n\t * @param {Function} drain callback\n\t * @api private\n\t */\n\t\n\tPolling.prototype.write = function (packets) {\n\t  var self = this;\n\t  this.writable = false;\n\t  var callbackfn = function () {\n\t    self.writable = true;\n\t    self.emit('drain');\n\t  };\n\t\n\t  parser.encodePayload(packets, this.supportsBinary, function (data) {\n\t    self.doWrite(data, callbackfn);\n\t  });\n\t};\n\t\n\t/**\n\t * Generates uri for connection.\n\t *\n\t * @api private\n\t */\n\t\n\tPolling.prototype.uri = function () {\n\t  var query = this.query || {};\n\t  var schema = this.secure ? 'https' : 'http';\n\t  var port = '';\n\t\n\t  // cache busting is forced\n\t  if (false !== this.timestampRequests) {\n\t    query[this.timestampParam] = yeast();\n\t  }\n\t\n\t  if (!this.supportsBinary && !query.sid) {\n\t    query.b64 = 1;\n\t  }\n\t\n\t  query = parseqs.encode(query);\n\t\n\t  // avoid port if default for schema\n\t  if (this.port && (('https' === schema && Number(this.port) !== 443) ||\n\t     ('http' === schema && Number(this.port) !== 80))) {\n\t    port = ':' + this.port;\n\t  }\n\t\n\t  // prepend ? to query\n\t  if (query.length) {\n\t    query = '?' + query;\n\t  }\n\t\n\t  var ipv6 = this.hostname.indexOf(':') !== -1;\n\t  return schema + '://' + (ipv6 ? '[' + this.hostname + ']' : this.hostname) + port + this.path + query;\n\t};\n\n\n/***/ },\n\n/***/ 472:\n/***/ function(module, exports, __webpack_require__) {\n\n\t/**\n\t * Module dependencies.\n\t */\n\t\n\tvar parser = __webpack_require__(473);\n\tvar Emitter = __webpack_require__(482);\n\t\n\t/**\n\t * Module exports.\n\t */\n\t\n\tmodule.exports = Transport;\n\t\n\t/**\n\t * Transport abstract constructor.\n\t *\n\t * @param {Object} options.\n\t * @api private\n\t */\n\t\n\tfunction Transport (opts) {\n\t  this.path = opts.path;\n\t  this.hostname = opts.hostname;\n\t  this.port = opts.port;\n\t  this.secure = opts.secure;\n\t  this.query = opts.query;\n\t  this.timestampParam = opts.timestampParam;\n\t  this.timestampRequests = opts.timestampRequests;\n\t  this.readyState = '';\n\t  this.agent = opts.agent || false;\n\t  this.socket = opts.socket;\n\t  this.enablesXDR = opts.enablesXDR;\n\t\n\t  // SSL options for Node.js client\n\t  this.pfx = opts.pfx;\n\t  this.key = opts.key;\n\t  this.passphrase = opts.passphrase;\n\t  this.cert = opts.cert;\n\t  this.ca = opts.ca;\n\t  this.ciphers = opts.ciphers;\n\t  this.rejectUnauthorized = opts.rejectUnauthorized;\n\t  this.forceNode = opts.forceNode;\n\t\n\t  // other options for Node.js client\n\t  this.extraHeaders = opts.extraHeaders;\n\t  this.localAddress = opts.localAddress;\n\t}\n\t\n\t/**\n\t * Mix in `Emitter`.\n\t */\n\t\n\tEmitter(Transport.prototype);\n\t\n\t/**\n\t * Emits an error.\n\t *\n\t * @param {String} str\n\t * @return {Transport} for chaining\n\t * @api public\n\t */\n\t\n\tTransport.prototype.onError = function (msg, desc) {\n\t  var err = new Error(msg);\n\t  err.type = 'TransportError';\n\t  err.description = desc;\n\t  this.emit('error', err);\n\t  return this;\n\t};\n\t\n\t/**\n\t * Opens the transport.\n\t *\n\t * @api public\n\t */\n\t\n\tTransport.prototype.open = function () {\n\t  if ('closed' === this.readyState || '' === this.readyState) {\n\t    this.readyState = 'opening';\n\t    this.doOpen();\n\t  }\n\t\n\t  return this;\n\t};\n\t\n\t/**\n\t * Closes the transport.\n\t *\n\t * @api private\n\t */\n\t\n\tTransport.prototype.close = function () {\n\t  if ('opening' === this.readyState || 'open' === this.readyState) {\n\t    this.doClose();\n\t    this.onClose();\n\t  }\n\t\n\t  return this;\n\t};\n\t\n\t/**\n\t * Sends multiple packets.\n\t *\n\t * @param {Array} packets\n\t * @api private\n\t */\n\t\n\tTransport.prototype.send = function (packets) {\n\t  if ('open' === this.readyState) {\n\t    this.write(packets);\n\t  } else {\n\t    throw new Error('Transport not open');\n\t  }\n\t};\n\t\n\t/**\n\t * Called upon open\n\t *\n\t * @api private\n\t */\n\t\n\tTransport.prototype.onOpen = function () {\n\t  this.readyState = 'open';\n\t  this.writable = true;\n\t  this.emit('open');\n\t};\n\t\n\t/**\n\t * Called with data.\n\t *\n\t * @param {String} data\n\t * @api private\n\t */\n\t\n\tTransport.prototype.onData = function (data) {\n\t  var packet = parser.decodePacket(data, this.socket.binaryType);\n\t  this.onPacket(packet);\n\t};\n\t\n\t/**\n\t * Called with a decoded packet.\n\t */\n\t\n\tTransport.prototype.onPacket = function (packet) {\n\t  this.emit('packet', packet);\n\t};\n\t\n\t/**\n\t * Called upon close.\n\t *\n\t * @api private\n\t */\n\t\n\tTransport.prototype.onClose = function () {\n\t  this.readyState = 'closed';\n\t  this.emit('close');\n\t};\n\n\n/***/ },\n\n/***/ 473:\n/***/ function(module, exports, __webpack_require__) {\n\n\t/* WEBPACK VAR INJECTION */(function(global) {/**\n\t * Module dependencies.\n\t */\n\t\n\tvar keys = __webpack_require__(474);\n\tvar hasBinary = __webpack_require__(475);\n\tvar sliceBuffer = __webpack_require__(477);\n\tvar after = __webpack_require__(478);\n\tvar utf8 = __webpack_require__(479);\n\t\n\tvar base64encoder;\n\tif (global && global.ArrayBuffer) {\n\t  base64encoder = __webpack_require__(480);\n\t}\n\t\n\t/**\n\t * Check if we are running an android browser. That requires us to use\n\t * ArrayBuffer with polling transports...\n\t *\n\t * http://ghinda.net/jpeg-blob-ajax-android/\n\t */\n\t\n\tvar isAndroid = typeof navigator !== 'undefined' && /Android/i.test(navigator.userAgent);\n\t\n\t/**\n\t * Check if we are running in PhantomJS.\n\t * Uploading a Blob with PhantomJS does not work correctly, as reported here:\n\t * https://github.com/ariya/phantomjs/issues/11395\n\t * @type boolean\n\t */\n\tvar isPhantomJS = typeof navigator !== 'undefined' && /PhantomJS/i.test(navigator.userAgent);\n\t\n\t/**\n\t * When true, avoids using Blobs to encode payloads.\n\t * @type boolean\n\t */\n\tvar dontSendBlobs = isAndroid || isPhantomJS;\n\t\n\t/**\n\t * Current protocol version.\n\t */\n\t\n\texports.protocol = 3;\n\t\n\t/**\n\t * Packet types.\n\t */\n\t\n\tvar packets = exports.packets = {\n\t    open:     0    // non-ws\n\t  , close:    1    // non-ws\n\t  , ping:     2\n\t  , pong:     3\n\t  , message:  4\n\t  , upgrade:  5\n\t  , noop:     6\n\t};\n\t\n\tvar packetslist = keys(packets);\n\t\n\t/**\n\t * Premade error packet.\n\t */\n\t\n\tvar err = { type: 'error', data: 'parser error' };\n\t\n\t/**\n\t * Create a blob api even for blob builder when vendor prefixes exist\n\t */\n\t\n\tvar Blob = __webpack_require__(481);\n\t\n\t/**\n\t * Encodes a packet.\n\t *\n\t *     <packet type id> [ <data> ]\n\t *\n\t * Example:\n\t *\n\t *     5hello world\n\t *     3\n\t *     4\n\t *\n\t * Binary is encoded in an identical principle\n\t *\n\t * @api private\n\t */\n\t\n\texports.encodePacket = function (packet, supportsBinary, utf8encode, callback) {\n\t  if ('function' == typeof supportsBinary) {\n\t    callback = supportsBinary;\n\t    supportsBinary = false;\n\t  }\n\t\n\t  if ('function' == typeof utf8encode) {\n\t    callback = utf8encode;\n\t    utf8encode = null;\n\t  }\n\t\n\t  var data = (packet.data === undefined)\n\t    ? undefined\n\t    : packet.data.buffer || packet.data;\n\t\n\t  if (global.ArrayBuffer && data instanceof ArrayBuffer) {\n\t    return encodeArrayBuffer(packet, supportsBinary, callback);\n\t  } else if (Blob && data instanceof global.Blob) {\n\t    return encodeBlob(packet, supportsBinary, callback);\n\t  }\n\t\n\t  // might be an object with { base64: true, data: dataAsBase64String }\n\t  if (data && data.base64) {\n\t    return encodeBase64Object(packet, callback);\n\t  }\n\t\n\t  // Sending data as a utf-8 string\n\t  var encoded = packets[packet.type];\n\t\n\t  // data fragment is optional\n\t  if (undefined !== packet.data) {\n\t    encoded += utf8encode ? utf8.encode(String(packet.data)) : String(packet.data);\n\t  }\n\t\n\t  return callback('' + encoded);\n\t\n\t};\n\t\n\tfunction encodeBase64Object(packet, callback) {\n\t  // packet data is an object { base64: true, data: dataAsBase64String }\n\t  var message = 'b' + exports.packets[packet.type] + packet.data.data;\n\t  return callback(message);\n\t}\n\t\n\t/**\n\t * Encode packet helpers for binary types\n\t */\n\t\n\tfunction encodeArrayBuffer(packet, supportsBinary, callback) {\n\t  if (!supportsBinary) {\n\t    return exports.encodeBase64Packet(packet, callback);\n\t  }\n\t\n\t  var data = packet.data;\n\t  var contentArray = new Uint8Array(data);\n\t  var resultBuffer = new Uint8Array(1 + data.byteLength);\n\t\n\t  resultBuffer[0] = packets[packet.type];\n\t  for (var i = 0; i < contentArray.length; i++) {\n\t    resultBuffer[i+1] = contentArray[i];\n\t  }\n\t\n\t  return callback(resultBuffer.buffer);\n\t}\n\t\n\tfunction encodeBlobAsArrayBuffer(packet, supportsBinary, callback) {\n\t  if (!supportsBinary) {\n\t    return exports.encodeBase64Packet(packet, callback);\n\t  }\n\t\n\t  var fr = new FileReader();\n\t  fr.onload = function() {\n\t    packet.data = fr.result;\n\t    exports.encodePacket(packet, supportsBinary, true, callback);\n\t  };\n\t  return fr.readAsArrayBuffer(packet.data);\n\t}\n\t\n\tfunction encodeBlob(packet, supportsBinary, callback) {\n\t  if (!supportsBinary) {\n\t    return exports.encodeBase64Packet(packet, callback);\n\t  }\n\t\n\t  if (dontSendBlobs) {\n\t    return encodeBlobAsArrayBuffer(packet, supportsBinary, callback);\n\t  }\n\t\n\t  var length = new Uint8Array(1);\n\t  length[0] = packets[packet.type];\n\t  var blob = new Blob([length.buffer, packet.data]);\n\t\n\t  return callback(blob);\n\t}\n\t\n\t/**\n\t * Encodes a packet with binary data in a base64 string\n\t *\n\t * @param {Object} packet, has `type` and `data`\n\t * @return {String} base64 encoded message\n\t */\n\t\n\texports.encodeBase64Packet = function(packet, callback) {\n\t  var message = 'b' + exports.packets[packet.type];\n\t  if (Blob && packet.data instanceof global.Blob) {\n\t    var fr = new FileReader();\n\t    fr.onload = function() {\n\t      var b64 = fr.result.split(',')[1];\n\t      callback(message + b64);\n\t    };\n\t    return fr.readAsDataURL(packet.data);\n\t  }\n\t\n\t  var b64data;\n\t  try {\n\t    b64data = String.fromCharCode.apply(null, new Uint8Array(packet.data));\n\t  } catch (e) {\n\t    // iPhone Safari doesn't let you apply with typed arrays\n\t    var typed = new Uint8Array(packet.data);\n\t    var basic = new Array(typed.length);\n\t    for (var i = 0; i < typed.length; i++) {\n\t      basic[i] = typed[i];\n\t    }\n\t    b64data = String.fromCharCode.apply(null, basic);\n\t  }\n\t  message += global.btoa(b64data);\n\t  return callback(message);\n\t};\n\t\n\t/**\n\t * Decodes a packet. Changes format to Blob if requested.\n\t *\n\t * @return {Object} with `type` and `data` (if any)\n\t * @api private\n\t */\n\t\n\texports.decodePacket = function (data, binaryType, utf8decode) {\n\t  if (data === undefined) {\n\t    return err;\n\t  }\n\t  // String data\n\t  if (typeof data == 'string') {\n\t    if (data.charAt(0) == 'b') {\n\t      return exports.decodeBase64Packet(data.substr(1), binaryType);\n\t    }\n\t\n\t    if (utf8decode) {\n\t      data = tryDecode(data);\n\t      if (data === false) {\n\t        return err;\n\t      }\n\t    }\n\t    var type = data.charAt(0);\n\t\n\t    if (Number(type) != type || !packetslist[type]) {\n\t      return err;\n\t    }\n\t\n\t    if (data.length > 1) {\n\t      return { type: packetslist[type], data: data.substring(1) };\n\t    } else {\n\t      return { type: packetslist[type] };\n\t    }\n\t  }\n\t\n\t  var asArray = new Uint8Array(data);\n\t  var type = asArray[0];\n\t  var rest = sliceBuffer(data, 1);\n\t  if (Blob && binaryType === 'blob') {\n\t    rest = new Blob([rest]);\n\t  }\n\t  return { type: packetslist[type], data: rest };\n\t};\n\t\n\tfunction tryDecode(data) {\n\t  try {\n\t    data = utf8.decode(data);\n\t  } catch (e) {\n\t    return false;\n\t  }\n\t  return data;\n\t}\n\t\n\t/**\n\t * Decodes a packet encoded in a base64 string\n\t *\n\t * @param {String} base64 encoded message\n\t * @return {Object} with `type` and `data` (if any)\n\t */\n\t\n\texports.decodeBase64Packet = function(msg, binaryType) {\n\t  var type = packetslist[msg.charAt(0)];\n\t  if (!base64encoder) {\n\t    return { type: type, data: { base64: true, data: msg.substr(1) } };\n\t  }\n\t\n\t  var data = base64encoder.decode(msg.substr(1));\n\t\n\t  if (binaryType === 'blob' && Blob) {\n\t    data = new Blob([data]);\n\t  }\n\t\n\t  return { type: type, data: data };\n\t};\n\t\n\t/**\n\t * Encodes multiple messages (payload).\n\t *\n\t *     <length>:data\n\t *\n\t * Example:\n\t *\n\t *     11:hello world2:hi\n\t *\n\t * If any contents are binary, they will be encoded as base64 strings. Base64\n\t * encoded strings are marked with a b before the length specifier\n\t *\n\t * @param {Array} packets\n\t * @api private\n\t */\n\t\n\texports.encodePayload = function (packets, supportsBinary, callback) {\n\t  if (typeof supportsBinary == 'function') {\n\t    callback = supportsBinary;\n\t    supportsBinary = null;\n\t  }\n\t\n\t  var isBinary = hasBinary(packets);\n\t\n\t  if (supportsBinary && isBinary) {\n\t    if (Blob && !dontSendBlobs) {\n\t      return exports.encodePayloadAsBlob(packets, callback);\n\t    }\n\t\n\t    return exports.encodePayloadAsArrayBuffer(packets, callback);\n\t  }\n\t\n\t  if (!packets.length) {\n\t    return callback('0:');\n\t  }\n\t\n\t  function setLengthHeader(message) {\n\t    return message.length + ':' + message;\n\t  }\n\t\n\t  function encodeOne(packet, doneCallback) {\n\t    exports.encodePacket(packet, !isBinary ? false : supportsBinary, true, function(message) {\n\t      doneCallback(null, setLengthHeader(message));\n\t    });\n\t  }\n\t\n\t  map(packets, encodeOne, function(err, results) {\n\t    return callback(results.join(''));\n\t  });\n\t};\n\t\n\t/**\n\t * Async array map using after\n\t */\n\t\n\tfunction map(ary, each, done) {\n\t  var result = new Array(ary.length);\n\t  var next = after(ary.length, done);\n\t\n\t  var eachWithIndex = function(i, el, cb) {\n\t    each(el, function(error, msg) {\n\t      result[i] = msg;\n\t      cb(error, result);\n\t    });\n\t  };\n\t\n\t  for (var i = 0; i < ary.length; i++) {\n\t    eachWithIndex(i, ary[i], next);\n\t  }\n\t}\n\t\n\t/*\n\t * Decodes data when a payload is maybe expected. Possible binary contents are\n\t * decoded from their base64 representation\n\t *\n\t * @param {String} data, callback method\n\t * @api public\n\t */\n\t\n\texports.decodePayload = function (data, binaryType, callback) {\n\t  if (typeof data != 'string') {\n\t    return exports.decodePayloadAsBinary(data, binaryType, callback);\n\t  }\n\t\n\t  if (typeof binaryType === 'function') {\n\t    callback = binaryType;\n\t    binaryType = null;\n\t  }\n\t\n\t  var packet;\n\t  if (data == '') {\n\t    // parser error - ignoring payload\n\t    return callback(err, 0, 1);\n\t  }\n\t\n\t  var length = ''\n\t    , n, msg;\n\t\n\t  for (var i = 0, l = data.length; i < l; i++) {\n\t    var chr = data.charAt(i);\n\t\n\t    if (':' != chr) {\n\t      length += chr;\n\t    } else {\n\t      if ('' == length || (length != (n = Number(length)))) {\n\t        // parser error - ignoring payload\n\t        return callback(err, 0, 1);\n\t      }\n\t\n\t      msg = data.substr(i + 1, n);\n\t\n\t      if (length != msg.length) {\n\t        // parser error - ignoring payload\n\t        return callback(err, 0, 1);\n\t      }\n\t\n\t      if (msg.length) {\n\t        packet = exports.decodePacket(msg, binaryType, true);\n\t\n\t        if (err.type == packet.type && err.data == packet.data) {\n\t          // parser error in individual packet - ignoring payload\n\t          return callback(err, 0, 1);\n\t        }\n\t\n\t        var ret = callback(packet, i + n, l);\n\t        if (false === ret) return;\n\t      }\n\t\n\t      // advance cursor\n\t      i += n;\n\t      length = '';\n\t    }\n\t  }\n\t\n\t  if (length != '') {\n\t    // parser error - ignoring payload\n\t    return callback(err, 0, 1);\n\t  }\n\t\n\t};\n\t\n\t/**\n\t * Encodes multiple messages (payload) as binary.\n\t *\n\t * <1 = binary, 0 = string><number from 0-9><number from 0-9>[...]<number\n\t * 255><data>\n\t *\n\t * Example:\n\t * 1 3 255 1 2 3, if the binary contents are interpreted as 8 bit integers\n\t *\n\t * @param {Array} packets\n\t * @return {ArrayBuffer} encoded payload\n\t * @api private\n\t */\n\t\n\texports.encodePayloadAsArrayBuffer = function(packets, callback) {\n\t  if (!packets.length) {\n\t    return callback(new ArrayBuffer(0));\n\t  }\n\t\n\t  function encodeOne(packet, doneCallback) {\n\t    exports.encodePacket(packet, true, true, function(data) {\n\t      return doneCallback(null, data);\n\t    });\n\t  }\n\t\n\t  map(packets, encodeOne, function(err, encodedPackets) {\n\t    var totalLength = encodedPackets.reduce(function(acc, p) {\n\t      var len;\n\t      if (typeof p === 'string'){\n\t        len = p.length;\n\t      } else {\n\t        len = p.byteLength;\n\t      }\n\t      return acc + len.toString().length + len + 2; // string/binary identifier + separator = 2\n\t    }, 0);\n\t\n\t    var resultArray = new Uint8Array(totalLength);\n\t\n\t    var bufferIndex = 0;\n\t    encodedPackets.forEach(function(p) {\n\t      var isString = typeof p === 'string';\n\t      var ab = p;\n\t      if (isString) {\n\t        var view = new Uint8Array(p.length);\n\t        for (var i = 0; i < p.length; i++) {\n\t          view[i] = p.charCodeAt(i);\n\t        }\n\t        ab = view.buffer;\n\t      }\n\t\n\t      if (isString) { // not true binary\n\t        resultArray[bufferIndex++] = 0;\n\t      } else { // true binary\n\t        resultArray[bufferIndex++] = 1;\n\t      }\n\t\n\t      var lenStr = ab.byteLength.toString();\n\t      for (var i = 0; i < lenStr.length; i++) {\n\t        resultArray[bufferIndex++] = parseInt(lenStr[i]);\n\t      }\n\t      resultArray[bufferIndex++] = 255;\n\t\n\t      var view = new Uint8Array(ab);\n\t      for (var i = 0; i < view.length; i++) {\n\t        resultArray[bufferIndex++] = view[i];\n\t      }\n\t    });\n\t\n\t    return callback(resultArray.buffer);\n\t  });\n\t};\n\t\n\t/**\n\t * Encode as Blob\n\t */\n\t\n\texports.encodePayloadAsBlob = function(packets, callback) {\n\t  function encodeOne(packet, doneCallback) {\n\t    exports.encodePacket(packet, true, true, function(encoded) {\n\t      var binaryIdentifier = new Uint8Array(1);\n\t      binaryIdentifier[0] = 1;\n\t      if (typeof encoded === 'string') {\n\t        var view = new Uint8Array(encoded.length);\n\t        for (var i = 0; i < encoded.length; i++) {\n\t          view[i] = encoded.charCodeAt(i);\n\t        }\n\t        encoded = view.buffer;\n\t        binaryIdentifier[0] = 0;\n\t      }\n\t\n\t      var len = (encoded instanceof ArrayBuffer)\n\t        ? encoded.byteLength\n\t        : encoded.size;\n\t\n\t      var lenStr = len.toString();\n\t      var lengthAry = new Uint8Array(lenStr.length + 1);\n\t      for (var i = 0; i < lenStr.length; i++) {\n\t        lengthAry[i] = parseInt(lenStr[i]);\n\t      }\n\t      lengthAry[lenStr.length] = 255;\n\t\n\t      if (Blob) {\n\t        var blob = new Blob([binaryIdentifier.buffer, lengthAry.buffer, encoded]);\n\t        doneCallback(null, blob);\n\t      }\n\t    });\n\t  }\n\t\n\t  map(packets, encodeOne, function(err, results) {\n\t    return callback(new Blob(results));\n\t  });\n\t};\n\t\n\t/*\n\t * Decodes data when a payload is maybe expected. Strings are decoded by\n\t * interpreting each byte as a key code for entries marked to start with 0. See\n\t * description of encodePayloadAsBinary\n\t *\n\t * @param {ArrayBuffer} data, callback method\n\t * @api public\n\t */\n\t\n\texports.decodePayloadAsBinary = function (data, binaryType, callback) {\n\t  if (typeof binaryType === 'function') {\n\t    callback = binaryType;\n\t    binaryType = null;\n\t  }\n\t\n\t  var bufferTail = data;\n\t  var buffers = [];\n\t\n\t  var numberTooLong = false;\n\t  while (bufferTail.byteLength > 0) {\n\t    var tailArray = new Uint8Array(bufferTail);\n\t    var isString = tailArray[0] === 0;\n\t    var msgLength = '';\n\t\n\t    for (var i = 1; ; i++) {\n\t      if (tailArray[i] == 255) break;\n\t\n\t      if (msgLength.length > 310) {\n\t        numberTooLong = true;\n\t        break;\n\t      }\n\t\n\t      msgLength += tailArray[i];\n\t    }\n\t\n\t    if(numberTooLong) return callback(err, 0, 1);\n\t\n\t    bufferTail = sliceBuffer(bufferTail, 2 + msgLength.length);\n\t    msgLength = parseInt(msgLength);\n\t\n\t    var msg = sliceBuffer(bufferTail, 0, msgLength);\n\t    if (isString) {\n\t      try {\n\t        msg = String.fromCharCode.apply(null, new Uint8Array(msg));\n\t      } catch (e) {\n\t        // iPhone Safari doesn't let you apply to typed arrays\n\t        var typed = new Uint8Array(msg);\n\t        msg = '';\n\t        for (var i = 0; i < typed.length; i++) {\n\t          msg += String.fromCharCode(typed[i]);\n\t        }\n\t      }\n\t    }\n\t\n\t    buffers.push(msg);\n\t    bufferTail = sliceBuffer(bufferTail, msgLength);\n\t  }\n\t\n\t  var total = buffers.length;\n\t  buffers.forEach(function(buffer, i) {\n\t    callback(exports.decodePacket(buffer, binaryType, true), i, total);\n\t  });\n\t};\n\t\n\t/* WEBPACK VAR INJECTION */}.call(exports, (function() { return this; }())))\n\n/***/ },\n\n/***/ 474:\n/***/ function(module, exports) {\n\n\t\n\t/**\n\t * Gets the keys for an object.\n\t *\n\t * @return {Array} keys\n\t * @api private\n\t */\n\t\n\tmodule.exports = Object.keys || function keys (obj){\n\t  var arr = [];\n\t  var has = Object.prototype.hasOwnProperty;\n\t\n\t  for (var i in obj) {\n\t    if (has.call(obj, i)) {\n\t      arr.push(i);\n\t    }\n\t  }\n\t  return arr;\n\t};\n\n\n/***/ },\n\n/***/ 475:\n/***/ function(module, exports, __webpack_require__) {\n\n\t/* WEBPACK VAR INJECTION */(function(global) {\n\t/*\n\t * Module requirements.\n\t */\n\t\n\tvar isArray = __webpack_require__(476);\n\t\n\t/**\n\t * Module exports.\n\t */\n\t\n\tmodule.exports = hasBinary;\n\t\n\t/**\n\t * Checks for binary data.\n\t *\n\t * Right now only Buffer and ArrayBuffer are supported..\n\t *\n\t * @param {Object} anything\n\t * @api public\n\t */\n\t\n\tfunction hasBinary(data) {\n\t\n\t  function _hasBinary(obj) {\n\t    if (!obj) return false;\n\t\n\t    if ( (global.Buffer && global.Buffer.isBuffer && global.Buffer.isBuffer(obj)) ||\n\t         (global.ArrayBuffer && obj instanceof ArrayBuffer) ||\n\t         (global.Blob && obj instanceof Blob) ||\n\t         (global.File && obj instanceof File)\n\t        ) {\n\t      return true;\n\t    }\n\t\n\t    if (isArray(obj)) {\n\t      for (var i = 0; i < obj.length; i++) {\n\t          if (_hasBinary(obj[i])) {\n\t              return true;\n\t          }\n\t      }\n\t    } else if (obj && 'object' == typeof obj) {\n\t      // see: https://github.com/Automattic/has-binary/pull/4\n\t      if (obj.toJSON && 'function' == typeof obj.toJSON) {\n\t        obj = obj.toJSON();\n\t      }\n\t\n\t      for (var key in obj) {\n\t        if (Object.prototype.hasOwnProperty.call(obj, key) && _hasBinary(obj[key])) {\n\t          return true;\n\t        }\n\t      }\n\t    }\n\t\n\t    return false;\n\t  }\n\t\n\t  return _hasBinary(data);\n\t}\n\t\n\t/* WEBPACK VAR INJECTION */}.call(exports, (function() { return this; }())))\n\n/***/ },\n\n/***/ 476:\n461,\n\n/***/ 477:\n/***/ function(module, exports) {\n\n\t/**\n\t * An abstraction for slicing an arraybuffer even when\n\t * ArrayBuffer.prototype.slice is not supported\n\t *\n\t * @api public\n\t */\n\t\n\tmodule.exports = function(arraybuffer, start, end) {\n\t  var bytes = arraybuffer.byteLength;\n\t  start = start || 0;\n\t  end = end || bytes;\n\t\n\t  if (arraybuffer.slice) { return arraybuffer.slice(start, end); }\n\t\n\t  if (start < 0) { start += bytes; }\n\t  if (end < 0) { end += bytes; }\n\t  if (end > bytes) { end = bytes; }\n\t\n\t  if (start >= bytes || start >= end || bytes === 0) {\n\t    return new ArrayBuffer(0);\n\t  }\n\t\n\t  var abv = new Uint8Array(arraybuffer);\n\t  var result = new Uint8Array(end - start);\n\t  for (var i = start, ii = 0; i < end; i++, ii++) {\n\t    result[ii] = abv[i];\n\t  }\n\t  return result.buffer;\n\t};\n\n\n/***/ },\n\n/***/ 478:\n/***/ function(module, exports) {\n\n\tmodule.exports = after\n\t\n\tfunction after(count, callback, err_cb) {\n\t    var bail = false\n\t    err_cb = err_cb || noop\n\t    proxy.count = count\n\t\n\t    return (count === 0) ? callback() : proxy\n\t\n\t    function proxy(err, result) {\n\t        if (proxy.count <= 0) {\n\t            throw new Error('after called too many times')\n\t        }\n\t        --proxy.count\n\t\n\t        // after first error, rest are passed to err_cb\n\t        if (err) {\n\t            bail = true\n\t            callback(err)\n\t            // future error callbacks will go to error handler\n\t            callback = err_cb\n\t        } else if (proxy.count === 0 && !bail) {\n\t            callback(null, result)\n\t        }\n\t    }\n\t}\n\t\n\tfunction noop() {}\n\n\n/***/ },\n\n/***/ 479:\n/***/ function(module, exports, __webpack_require__) {\n\n\tvar __WEBPACK_AMD_DEFINE_RESULT__;/* WEBPACK VAR INJECTION */(function(module, global) {/*! https://mths.be/wtf8 v1.0.0 by @mathias */\n\t;(function(root) {\n\t\n\t\t// Detect free variables `exports`\n\t\tvar freeExports = typeof exports == 'object' && exports;\n\t\n\t\t// Detect free variable `module`\n\t\tvar freeModule = typeof module == 'object' && module &&\n\t\t\tmodule.exports == freeExports && module;\n\t\n\t\t// Detect free variable `global`, from Node.js or Browserified code,\n\t\t// and use it as `root`\n\t\tvar freeGlobal = typeof global == 'object' && global;\n\t\tif (freeGlobal.global === freeGlobal || freeGlobal.window === freeGlobal) {\n\t\t\troot = freeGlobal;\n\t\t}\n\t\n\t\t/*--------------------------------------------------------------------------*/\n\t\n\t\tvar stringFromCharCode = String.fromCharCode;\n\t\n\t\t// Taken from https://mths.be/punycode\n\t\tfunction ucs2decode(string) {\n\t\t\tvar output = [];\n\t\t\tvar counter = 0;\n\t\t\tvar length = string.length;\n\t\t\tvar value;\n\t\t\tvar extra;\n\t\t\twhile (counter < length) {\n\t\t\t\tvalue = string.charCodeAt(counter++);\n\t\t\t\tif (value >= 0xD800 && value <= 0xDBFF && counter < length) {\n\t\t\t\t\t// high surrogate, and there is a next character\n\t\t\t\t\textra = string.charCodeAt(counter++);\n\t\t\t\t\tif ((extra & 0xFC00) == 0xDC00) { // low surrogate\n\t\t\t\t\t\toutput.push(((value & 0x3FF) << 10) + (extra & 0x3FF) + 0x10000);\n\t\t\t\t\t} else {\n\t\t\t\t\t\t// unmatched surrogate; only append this code unit, in case the next\n\t\t\t\t\t\t// code unit is the high surrogate of a surrogate pair\n\t\t\t\t\t\toutput.push(value);\n\t\t\t\t\t\tcounter--;\n\t\t\t\t\t}\n\t\t\t\t} else {\n\t\t\t\t\toutput.push(value);\n\t\t\t\t}\n\t\t\t}\n\t\t\treturn output;\n\t\t}\n\t\n\t\t// Taken from https://mths.be/punycode\n\t\tfunction ucs2encode(array) {\n\t\t\tvar length = array.length;\n\t\t\tvar index = -1;\n\t\t\tvar value;\n\t\t\tvar output = '';\n\t\t\twhile (++index < length) {\n\t\t\t\tvalue = array[index];\n\t\t\t\tif (value > 0xFFFF) {\n\t\t\t\t\tvalue -= 0x10000;\n\t\t\t\t\toutput += stringFromCharCode(value >>> 10 & 0x3FF | 0xD800);\n\t\t\t\t\tvalue = 0xDC00 | value & 0x3FF;\n\t\t\t\t}\n\t\t\t\toutput += stringFromCharCode(value);\n\t\t\t}\n\t\t\treturn output;\n\t\t}\n\t\n\t\t/*--------------------------------------------------------------------------*/\n\t\n\t\tfunction createByte(codePoint, shift) {\n\t\t\treturn stringFromCharCode(((codePoint >> shift) & 0x3F) | 0x80);\n\t\t}\n\t\n\t\tfunction encodeCodePoint(codePoint) {\n\t\t\tif ((codePoint & 0xFFFFFF80) == 0) { // 1-byte sequence\n\t\t\t\treturn stringFromCharCode(codePoint);\n\t\t\t}\n\t\t\tvar symbol = '';\n\t\t\tif ((codePoint & 0xFFFFF800) == 0) { // 2-byte sequence\n\t\t\t\tsymbol = stringFromCharCode(((codePoint >> 6) & 0x1F) | 0xC0);\n\t\t\t}\n\t\t\telse if ((codePoint & 0xFFFF0000) == 0) { // 3-byte sequence\n\t\t\t\tsymbol = stringFromCharCode(((codePoint >> 12) & 0x0F) | 0xE0);\n\t\t\t\tsymbol += createByte(codePoint, 6);\n\t\t\t}\n\t\t\telse if ((codePoint & 0xFFE00000) == 0) { // 4-byte sequence\n\t\t\t\tsymbol = stringFromCharCode(((codePoint >> 18) & 0x07) | 0xF0);\n\t\t\t\tsymbol += createByte(codePoint, 12);\n\t\t\t\tsymbol += createByte(codePoint, 6);\n\t\t\t}\n\t\t\tsymbol += stringFromCharCode((codePoint & 0x3F) | 0x80);\n\t\t\treturn symbol;\n\t\t}\n\t\n\t\tfunction wtf8encode(string) {\n\t\t\tvar codePoints = ucs2decode(string);\n\t\t\tvar length = codePoints.length;\n\t\t\tvar index = -1;\n\t\t\tvar codePoint;\n\t\t\tvar byteString = '';\n\t\t\twhile (++index < length) {\n\t\t\t\tcodePoint = codePoints[index];\n\t\t\t\tbyteString += encodeCodePoint(codePoint);\n\t\t\t}\n\t\t\treturn byteString;\n\t\t}\n\t\n\t\t/*--------------------------------------------------------------------------*/\n\t\n\t\tfunction readContinuationByte() {\n\t\t\tif (byteIndex >= byteCount) {\n\t\t\t\tthrow Error('Invalid byte index');\n\t\t\t}\n\t\n\t\t\tvar continuationByte = byteArray[byteIndex] & 0xFF;\n\t\t\tbyteIndex++;\n\t\n\t\t\tif ((continuationByte & 0xC0) == 0x80) {\n\t\t\t\treturn continuationByte & 0x3F;\n\t\t\t}\n\t\n\t\t\t// If we end up here, it’s not a continuation byte.\n\t\t\tthrow Error('Invalid continuation byte');\n\t\t}\n\t\n\t\tfunction decodeSymbol() {\n\t\t\tvar byte1;\n\t\t\tvar byte2;\n\t\t\tvar byte3;\n\t\t\tvar byte4;\n\t\t\tvar codePoint;\n\t\n\t\t\tif (byteIndex > byteCount) {\n\t\t\t\tthrow Error('Invalid byte index');\n\t\t\t}\n\t\n\t\t\tif (byteIndex == byteCount) {\n\t\t\t\treturn false;\n\t\t\t}\n\t\n\t\t\t// Read the first byte.\n\t\t\tbyte1 = byteArray[byteIndex] & 0xFF;\n\t\t\tbyteIndex++;\n\t\n\t\t\t// 1-byte sequence (no continuation bytes)\n\t\t\tif ((byte1 & 0x80) == 0) {\n\t\t\t\treturn byte1;\n\t\t\t}\n\t\n\t\t\t// 2-byte sequence\n\t\t\tif ((byte1 & 0xE0) == 0xC0) {\n\t\t\t\tvar byte2 = readContinuationByte();\n\t\t\t\tcodePoint = ((byte1 & 0x1F) << 6) | byte2;\n\t\t\t\tif (codePoint >= 0x80) {\n\t\t\t\t\treturn codePoint;\n\t\t\t\t} else {\n\t\t\t\t\tthrow Error('Invalid continuation byte');\n\t\t\t\t}\n\t\t\t}\n\t\n\t\t\t// 3-byte sequence (may include unpaired surrogates)\n\t\t\tif ((byte1 & 0xF0) == 0xE0) {\n\t\t\t\tbyte2 = readContinuationByte();\n\t\t\t\tbyte3 = readContinuationByte();\n\t\t\t\tcodePoint = ((byte1 & 0x0F) << 12) | (byte2 << 6) | byte3;\n\t\t\t\tif (codePoint >= 0x0800) {\n\t\t\t\t\treturn codePoint;\n\t\t\t\t} else {\n\t\t\t\t\tthrow Error('Invalid continuation byte');\n\t\t\t\t}\n\t\t\t}\n\t\n\t\t\t// 4-byte sequence\n\t\t\tif ((byte1 & 0xF8) == 0xF0) {\n\t\t\t\tbyte2 = readContinuationByte();\n\t\t\t\tbyte3 = readContinuationByte();\n\t\t\t\tbyte4 = readContinuationByte();\n\t\t\t\tcodePoint = ((byte1 & 0x0F) << 0x12) | (byte2 << 0x0C) |\n\t\t\t\t\t(byte3 << 0x06) | byte4;\n\t\t\t\tif (codePoint >= 0x010000 && codePoint <= 0x10FFFF) {\n\t\t\t\t\treturn codePoint;\n\t\t\t\t}\n\t\t\t}\n\t\n\t\t\tthrow Error('Invalid WTF-8 detected');\n\t\t}\n\t\n\t\tvar byteArray;\n\t\tvar byteCount;\n\t\tvar byteIndex;\n\t\tfunction wtf8decode(byteString) {\n\t\t\tbyteArray = ucs2decode(byteString);\n\t\t\tbyteCount = byteArray.length;\n\t\t\tbyteIndex = 0;\n\t\t\tvar codePoints = [];\n\t\t\tvar tmp;\n\t\t\twhile ((tmp = decodeSymbol()) !== false) {\n\t\t\t\tcodePoints.push(tmp);\n\t\t\t}\n\t\t\treturn ucs2encode(codePoints);\n\t\t}\n\t\n\t\t/*--------------------------------------------------------------------------*/\n\t\n\t\tvar wtf8 = {\n\t\t\t'version': '1.0.0',\n\t\t\t'encode': wtf8encode,\n\t\t\t'decode': wtf8decode\n\t\t};\n\t\n\t\t// Some AMD build optimizers, like r.js, check for specific condition patterns\n\t\t// like the following:\n\t\tif (\n\t\t\ttrue\n\t\t) {\n\t\t\t!(__WEBPACK_AMD_DEFINE_RESULT__ = function() {\n\t\t\t\treturn wtf8;\n\t\t\t}.call(exports, __webpack_require__, exports, module), __WEBPACK_AMD_DEFINE_RESULT__ !== undefined && (module.exports = __WEBPACK_AMD_DEFINE_RESULT__));\n\t\t}\telse if (freeExports && !freeExports.nodeType) {\n\t\t\tif (freeModule) { // in Node.js or RingoJS v0.8.0+\n\t\t\t\tfreeModule.exports = wtf8;\n\t\t\t} else { // in Narwhal or RingoJS v0.7.0-\n\t\t\t\tvar object = {};\n\t\t\t\tvar hasOwnProperty = object.hasOwnProperty;\n\t\t\t\tfor (var key in wtf8) {\n\t\t\t\t\thasOwnProperty.call(wtf8, key) && (freeExports[key] = wtf8[key]);\n\t\t\t\t}\n\t\t\t}\n\t\t} else { // in Rhino or a web browser\n\t\t\troot.wtf8 = wtf8;\n\t\t}\n\t\n\t}(this));\n\t\n\t/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(457)(module), (function() { return this; }())))\n\n/***/ },\n\n/***/ 480:\n/***/ function(module, exports) {\n\n\t/*\n\t * base64-arraybuffer\n\t * https://github.com/niklasvh/base64-arraybuffer\n\t *\n\t * Copyright (c) 2012 Niklas von Hertzen\n\t * Licensed under the MIT license.\n\t */\n\t(function(){\n\t  \"use strict\";\n\t\n\t  var chars = \"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/\";\n\t\n\t  // Use a lookup table to find the index.\n\t  var lookup = new Uint8Array(256);\n\t  for (var i = 0; i < chars.length; i++) {\n\t    lookup[chars.charCodeAt(i)] = i;\n\t  }\n\t\n\t  exports.encode = function(arraybuffer) {\n\t    var bytes = new Uint8Array(arraybuffer),\n\t    i, len = bytes.length, base64 = \"\";\n\t\n\t    for (i = 0; i < len; i+=3) {\n\t      base64 += chars[bytes[i] >> 2];\n\t      base64 += chars[((bytes[i] & 3) << 4) | (bytes[i + 1] >> 4)];\n\t      base64 += chars[((bytes[i + 1] & 15) << 2) | (bytes[i + 2] >> 6)];\n\t      base64 += chars[bytes[i + 2] & 63];\n\t    }\n\t\n\t    if ((len % 3) === 2) {\n\t      base64 = base64.substring(0, base64.length - 1) + \"=\";\n\t    } else if (len % 3 === 1) {\n\t      base64 = base64.substring(0, base64.length - 2) + \"==\";\n\t    }\n\t\n\t    return base64;\n\t  };\n\t\n\t  exports.decode =  function(base64) {\n\t    var bufferLength = base64.length * 0.75,\n\t    len = base64.length, i, p = 0,\n\t    encoded1, encoded2, encoded3, encoded4;\n\t\n\t    if (base64[base64.length - 1] === \"=\") {\n\t      bufferLength--;\n\t      if (base64[base64.length - 2] === \"=\") {\n\t        bufferLength--;\n\t      }\n\t    }\n\t\n\t    var arraybuffer = new ArrayBuffer(bufferLength),\n\t    bytes = new Uint8Array(arraybuffer);\n\t\n\t    for (i = 0; i < len; i+=4) {\n\t      encoded1 = lookup[base64.charCodeAt(i)];\n\t      encoded2 = lookup[base64.charCodeAt(i+1)];\n\t      encoded3 = lookup[base64.charCodeAt(i+2)];\n\t      encoded4 = lookup[base64.charCodeAt(i+3)];\n\t\n\t      bytes[p++] = (encoded1 << 2) | (encoded2 >> 4);\n\t      bytes[p++] = ((encoded2 & 15) << 4) | (encoded3 >> 2);\n\t      bytes[p++] = ((encoded3 & 3) << 6) | (encoded4 & 63);\n\t    }\n\t\n\t    return arraybuffer;\n\t  };\n\t})();\n\n\n/***/ },\n\n/***/ 481:\n/***/ function(module, exports) {\n\n\t/* WEBPACK VAR INJECTION */(function(global) {/**\n\t * Create a blob builder even when vendor prefixes exist\n\t */\n\t\n\tvar BlobBuilder = global.BlobBuilder\n\t  || global.WebKitBlobBuilder\n\t  || global.MSBlobBuilder\n\t  || global.MozBlobBuilder;\n\t\n\t/**\n\t * Check if Blob constructor is supported\n\t */\n\t\n\tvar blobSupported = (function() {\n\t  try {\n\t    var a = new Blob(['hi']);\n\t    return a.size === 2;\n\t  } catch(e) {\n\t    return false;\n\t  }\n\t})();\n\t\n\t/**\n\t * Check if Blob constructor supports ArrayBufferViews\n\t * Fails in Safari 6, so we need to map to ArrayBuffers there.\n\t */\n\t\n\tvar blobSupportsArrayBufferView = blobSupported && (function() {\n\t  try {\n\t    var b = new Blob([new Uint8Array([1,2])]);\n\t    return b.size === 2;\n\t  } catch(e) {\n\t    return false;\n\t  }\n\t})();\n\t\n\t/**\n\t * Check if BlobBuilder is supported\n\t */\n\t\n\tvar blobBuilderSupported = BlobBuilder\n\t  && BlobBuilder.prototype.append\n\t  && BlobBuilder.prototype.getBlob;\n\t\n\t/**\n\t * Helper function that maps ArrayBufferViews to ArrayBuffers\n\t * Used by BlobBuilder constructor and old browsers that didn't\n\t * support it in the Blob constructor.\n\t */\n\t\n\tfunction mapArrayBufferViews(ary) {\n\t  for (var i = 0; i < ary.length; i++) {\n\t    var chunk = ary[i];\n\t    if (chunk.buffer instanceof ArrayBuffer) {\n\t      var buf = chunk.buffer;\n\t\n\t      // if this is a subarray, make a copy so we only\n\t      // include the subarray region from the underlying buffer\n\t      if (chunk.byteLength !== buf.byteLength) {\n\t        var copy = new Uint8Array(chunk.byteLength);\n\t        copy.set(new Uint8Array(buf, chunk.byteOffset, chunk.byteLength));\n\t        buf = copy.buffer;\n\t      }\n\t\n\t      ary[i] = buf;\n\t    }\n\t  }\n\t}\n\t\n\tfunction BlobBuilderConstructor(ary, options) {\n\t  options = options || {};\n\t\n\t  var bb = new BlobBuilder();\n\t  mapArrayBufferViews(ary);\n\t\n\t  for (var i = 0; i < ary.length; i++) {\n\t    bb.append(ary[i]);\n\t  }\n\t\n\t  return (options.type) ? bb.getBlob(options.type) : bb.getBlob();\n\t};\n\t\n\tfunction BlobConstructor(ary, options) {\n\t  mapArrayBufferViews(ary);\n\t  return new Blob(ary, options || {});\n\t};\n\t\n\tmodule.exports = (function() {\n\t  if (blobSupported) {\n\t    return blobSupportsArrayBufferView ? global.Blob : BlobConstructor;\n\t  } else if (blobBuilderSupported) {\n\t    return BlobBuilderConstructor;\n\t  } else {\n\t    return undefined;\n\t  }\n\t})();\n\t\n\t/* WEBPACK VAR INJECTION */}.call(exports, (function() { return this; }())))\n\n/***/ },\n\n/***/ 482:\n/***/ function(module, exports, __webpack_require__) {\n\n\t\r\n\t/**\r\n\t * Expose `Emitter`.\r\n\t */\r\n\t\r\n\tif (true) {\r\n\t  module.exports = Emitter;\r\n\t}\r\n\t\r\n\t/**\r\n\t * Initialize a new `Emitter`.\r\n\t *\r\n\t * @api public\r\n\t */\r\n\t\r\n\tfunction Emitter(obj) {\r\n\t  if (obj) return mixin(obj);\r\n\t};\r\n\t\r\n\t/**\r\n\t * Mixin the emitter properties.\r\n\t *\r\n\t * @param {Object} obj\r\n\t * @return {Object}\r\n\t * @api private\r\n\t */\r\n\t\r\n\tfunction mixin(obj) {\r\n\t  for (var key in Emitter.prototype) {\r\n\t    obj[key] = Emitter.prototype[key];\r\n\t  }\r\n\t  return obj;\r\n\t}\r\n\t\r\n\t/**\r\n\t * Listen on the given `event` with `fn`.\r\n\t *\r\n\t * @param {String} event\r\n\t * @param {Function} fn\r\n\t * @return {Emitter}\r\n\t * @api public\r\n\t */\r\n\t\r\n\tEmitter.prototype.on =\r\n\tEmitter.prototype.addEventListener = function(event, fn){\r\n\t  this._callbacks = this._callbacks || {};\r\n\t  (this._callbacks['$' + event] = this._callbacks['$' + event] || [])\r\n\t    .push(fn);\r\n\t  return this;\r\n\t};\r\n\t\r\n\t/**\r\n\t * Adds an `event` listener that will be invoked a single\r\n\t * time then automatically removed.\r\n\t *\r\n\t * @param {String} event\r\n\t * @param {Function} fn\r\n\t * @return {Emitter}\r\n\t * @api public\r\n\t */\r\n\t\r\n\tEmitter.prototype.once = function(event, fn){\r\n\t  function on() {\r\n\t    this.off(event, on);\r\n\t    fn.apply(this, arguments);\r\n\t  }\r\n\t\r\n\t  on.fn = fn;\r\n\t  this.on(event, on);\r\n\t  return this;\r\n\t};\r\n\t\r\n\t/**\r\n\t * Remove the given callback for `event` or all\r\n\t * registered callbacks.\r\n\t *\r\n\t * @param {String} event\r\n\t * @param {Function} fn\r\n\t * @return {Emitter}\r\n\t * @api public\r\n\t */\r\n\t\r\n\tEmitter.prototype.off =\r\n\tEmitter.prototype.removeListener =\r\n\tEmitter.prototype.removeAllListeners =\r\n\tEmitter.prototype.removeEventListener = function(event, fn){\r\n\t  this._callbacks = this._callbacks || {};\r\n\t\r\n\t  // all\r\n\t  if (0 == arguments.length) {\r\n\t    this._callbacks = {};\r\n\t    return this;\r\n\t  }\r\n\t\r\n\t  // specific event\r\n\t  var callbacks = this._callbacks['$' + event];\r\n\t  if (!callbacks) return this;\r\n\t\r\n\t  // remove all handlers\r\n\t  if (1 == arguments.length) {\r\n\t    delete this._callbacks['$' + event];\r\n\t    return this;\r\n\t  }\r\n\t\r\n\t  // remove specific handler\r\n\t  var cb;\r\n\t  for (var i = 0; i < callbacks.length; i++) {\r\n\t    cb = callbacks[i];\r\n\t    if (cb === fn || cb.fn === fn) {\r\n\t      callbacks.splice(i, 1);\r\n\t      break;\r\n\t    }\r\n\t  }\r\n\t  return this;\r\n\t};\r\n\t\r\n\t/**\r\n\t * Emit `event` with the given args.\r\n\t *\r\n\t * @param {String} event\r\n\t * @param {Mixed} ...\r\n\t * @return {Emitter}\r\n\t */\r\n\t\r\n\tEmitter.prototype.emit = function(event){\r\n\t  this._callbacks = this._callbacks || {};\r\n\t  var args = [].slice.call(arguments, 1)\r\n\t    , callbacks = this._callbacks['$' + event];\r\n\t\r\n\t  if (callbacks) {\r\n\t    callbacks = callbacks.slice(0);\r\n\t    for (var i = 0, len = callbacks.length; i < len; ++i) {\r\n\t      callbacks[i].apply(this, args);\r\n\t    }\r\n\t  }\r\n\t\r\n\t  return this;\r\n\t};\r\n\t\r\n\t/**\r\n\t * Return array of callbacks for `event`.\r\n\t *\r\n\t * @param {String} event\r\n\t * @return {Array}\r\n\t * @api public\r\n\t */\r\n\t\r\n\tEmitter.prototype.listeners = function(event){\r\n\t  this._callbacks = this._callbacks || {};\r\n\t  return this._callbacks['$' + event] || [];\r\n\t};\r\n\t\r\n\t/**\r\n\t * Check if this emitter has `event` handlers.\r\n\t *\r\n\t * @param {String} event\r\n\t * @return {Boolean}\r\n\t * @api public\r\n\t */\r\n\t\r\n\tEmitter.prototype.hasListeners = function(event){\r\n\t  return !! this.listeners(event).length;\r\n\t};\r\n\n\n/***/ },\n\n/***/ 483:\n/***/ function(module, exports) {\n\n\t/**\r\n\t * Compiles a querystring\r\n\t * Returns string representation of the object\r\n\t *\r\n\t * @param {Object}\r\n\t * @api private\r\n\t */\r\n\t\r\n\texports.encode = function (obj) {\r\n\t  var str = '';\r\n\t\r\n\t  for (var i in obj) {\r\n\t    if (obj.hasOwnProperty(i)) {\r\n\t      if (str.length) str += '&';\r\n\t      str += encodeURIComponent(i) + '=' + encodeURIComponent(obj[i]);\r\n\t    }\r\n\t  }\r\n\t\r\n\t  return str;\r\n\t};\r\n\t\r\n\t/**\r\n\t * Parses a simple querystring into an object\r\n\t *\r\n\t * @param {String} qs\r\n\t * @api private\r\n\t */\r\n\t\r\n\texports.decode = function(qs){\r\n\t  var qry = {};\r\n\t  var pairs = qs.split('&');\r\n\t  for (var i = 0, l = pairs.length; i < l; i++) {\r\n\t    var pair = pairs[i].split('=');\r\n\t    qry[decodeURIComponent(pair[0])] = decodeURIComponent(pair[1]);\r\n\t  }\r\n\t  return qry;\r\n\t};\r\n\n\n/***/ },\n\n/***/ 484:\n/***/ function(module, exports) {\n\n\t\n\tmodule.exports = function(a, b){\n\t  var fn = function(){};\n\t  fn.prototype = b.prototype;\n\t  a.prototype = new fn;\n\t  a.prototype.constructor = a;\n\t};\n\n/***/ },\n\n/***/ 485:\n/***/ function(module, exports) {\n\n\t'use strict';\n\t\n\tvar alphabet = '0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz-_'.split('')\n\t  , length = 64\n\t  , map = {}\n\t  , seed = 0\n\t  , i = 0\n\t  , prev;\n\t\n\t/**\n\t * Return a string representing the specified number.\n\t *\n\t * @param {Number} num The number to convert.\n\t * @returns {String} The string representation of the number.\n\t * @api public\n\t */\n\tfunction encode(num) {\n\t  var encoded = '';\n\t\n\t  do {\n\t    encoded = alphabet[num % length] + encoded;\n\t    num = Math.floor(num / length);\n\t  } while (num > 0);\n\t\n\t  return encoded;\n\t}\n\t\n\t/**\n\t * Return the integer value specified by the given string.\n\t *\n\t * @param {String} str The string to convert.\n\t * @returns {Number} The integer value represented by the string.\n\t * @api public\n\t */\n\tfunction decode(str) {\n\t  var decoded = 0;\n\t\n\t  for (i = 0; i < str.length; i++) {\n\t    decoded = decoded * length + map[str.charAt(i)];\n\t  }\n\t\n\t  return decoded;\n\t}\n\t\n\t/**\n\t * Yeast: A tiny growing id generator.\n\t *\n\t * @returns {String} A unique id.\n\t * @api public\n\t */\n\tfunction yeast() {\n\t  var now = encode(+new Date());\n\t\n\t  if (now !== prev) return seed = 0, prev = now;\n\t  return now +'.'+ encode(seed++);\n\t}\n\t\n\t//\n\t// Map each character to its index.\n\t//\n\tfor (; i < length; i++) map[alphabet[i]] = i;\n\t\n\t//\n\t// Expose the `yeast`, `encode` and `decode` functions.\n\t//\n\tyeast.encode = encode;\n\tyeast.decode = decode;\n\tmodule.exports = yeast;\n\n\n/***/ },\n\n/***/ 486:\n[963, 487],\n\n/***/ 487:\n450,\n\n/***/ 488:\n/***/ function(module, exports, __webpack_require__) {\n\n\t/* WEBPACK VAR INJECTION */(function(global) {\n\t/**\n\t * Module requirements.\n\t */\n\t\n\tvar Polling = __webpack_require__(471);\n\tvar inherit = __webpack_require__(484);\n\t\n\t/**\n\t * Module exports.\n\t */\n\t\n\tmodule.exports = JSONPPolling;\n\t\n\t/**\n\t * Cached regular expressions.\n\t */\n\t\n\tvar rNewline = /\\n/g;\n\tvar rEscapedNewline = /\\\\n/g;\n\t\n\t/**\n\t * Global JSONP callbacks.\n\t */\n\t\n\tvar callbacks;\n\t\n\t/**\n\t * Noop.\n\t */\n\t\n\tfunction empty () { }\n\t\n\t/**\n\t * JSONP Polling constructor.\n\t *\n\t * @param {Object} opts.\n\t * @api public\n\t */\n\t\n\tfunction JSONPPolling (opts) {\n\t  Polling.call(this, opts);\n\t\n\t  this.query = this.query || {};\n\t\n\t  // define global callbacks array if not present\n\t  // we do this here (lazily) to avoid unneeded global pollution\n\t  if (!callbacks) {\n\t    // we need to consider multiple engines in the same page\n\t    if (!global.___eio) global.___eio = [];\n\t    callbacks = global.___eio;\n\t  }\n\t\n\t  // callback identifier\n\t  this.index = callbacks.length;\n\t\n\t  // add callback to jsonp global\n\t  var self = this;\n\t  callbacks.push(function (msg) {\n\t    self.onData(msg);\n\t  });\n\t\n\t  // append to query string\n\t  this.query.j = this.index;\n\t\n\t  // prevent spurious errors from being emitted when the window is unloaded\n\t  if (global.document && global.addEventListener) {\n\t    global.addEventListener('beforeunload', function () {\n\t      if (self.script) self.script.onerror = empty;\n\t    }, false);\n\t  }\n\t}\n\t\n\t/**\n\t * Inherits from Polling.\n\t */\n\t\n\tinherit(JSONPPolling, Polling);\n\t\n\t/*\n\t * JSONP only supports binary as base64 encoded strings\n\t */\n\t\n\tJSONPPolling.prototype.supportsBinary = false;\n\t\n\t/**\n\t * Closes the socket.\n\t *\n\t * @api private\n\t */\n\t\n\tJSONPPolling.prototype.doClose = function () {\n\t  if (this.script) {\n\t    this.script.parentNode.removeChild(this.script);\n\t    this.script = null;\n\t  }\n\t\n\t  if (this.form) {\n\t    this.form.parentNode.removeChild(this.form);\n\t    this.form = null;\n\t    this.iframe = null;\n\t  }\n\t\n\t  Polling.prototype.doClose.call(this);\n\t};\n\t\n\t/**\n\t * Starts a poll cycle.\n\t *\n\t * @api private\n\t */\n\t\n\tJSONPPolling.prototype.doPoll = function () {\n\t  var self = this;\n\t  var script = document.createElement('script');\n\t\n\t  if (this.script) {\n\t    this.script.parentNode.removeChild(this.script);\n\t    this.script = null;\n\t  }\n\t\n\t  script.async = true;\n\t  script.src = this.uri();\n\t  script.onerror = function (e) {\n\t    self.onError('jsonp poll error', e);\n\t  };\n\t\n\t  var insertAt = document.getElementsByTagName('script')[0];\n\t  if (insertAt) {\n\t    insertAt.parentNode.insertBefore(script, insertAt);\n\t  } else {\n\t    (document.head || document.body).appendChild(script);\n\t  }\n\t  this.script = script;\n\t\n\t  var isUAgecko = 'undefined' !== typeof navigator && /gecko/i.test(navigator.userAgent);\n\t\n\t  if (isUAgecko) {\n\t    setTimeout(function () {\n\t      var iframe = document.createElement('iframe');\n\t      document.body.appendChild(iframe);\n\t      document.body.removeChild(iframe);\n\t    }, 100);\n\t  }\n\t};\n\t\n\t/**\n\t * Writes with a hidden iframe.\n\t *\n\t * @param {String} data to send\n\t * @param {Function} called upon flush.\n\t * @api private\n\t */\n\t\n\tJSONPPolling.prototype.doWrite = function (data, fn) {\n\t  var self = this;\n\t\n\t  if (!this.form) {\n\t    var form = document.createElement('form');\n\t    var area = document.createElement('textarea');\n\t    var id = this.iframeId = 'eio_iframe_' + this.index;\n\t    var iframe;\n\t\n\t    form.className = 'socketio';\n\t    form.style.position = 'absolute';\n\t    form.style.top = '-1000px';\n\t    form.style.left = '-1000px';\n\t    form.target = id;\n\t    form.method = 'POST';\n\t    form.setAttribute('accept-charset', 'utf-8');\n\t    area.name = 'd';\n\t    form.appendChild(area);\n\t    document.body.appendChild(form);\n\t\n\t    this.form = form;\n\t    this.area = area;\n\t  }\n\t\n\t  this.form.action = this.uri();\n\t\n\t  function complete () {\n\t    initIframe();\n\t    fn();\n\t  }\n\t\n\t  function initIframe () {\n\t    if (self.iframe) {\n\t      try {\n\t        self.form.removeChild(self.iframe);\n\t      } catch (e) {\n\t        self.onError('jsonp polling iframe removal error', e);\n\t      }\n\t    }\n\t\n\t    try {\n\t      // ie6 dynamic iframes with target=\"\" support (thanks Chris Lambacher)\n\t      var html = '<iframe src=\"javascript:0\" name=\"' + self.iframeId + '\">';\n\t      iframe = document.createElement(html);\n\t    } catch (e) {\n\t      iframe = document.createElement('iframe');\n\t      iframe.name = self.iframeId;\n\t      iframe.src = 'javascript:0';\n\t    }\n\t\n\t    iframe.id = self.iframeId;\n\t\n\t    self.form.appendChild(iframe);\n\t    self.iframe = iframe;\n\t  }\n\t\n\t  initIframe();\n\t\n\t  // escape \\n to prevent it from being converted into \\r\\n by some UAs\n\t  // double escaping is required for escaped new lines because unescaping of new lines can be done safely on server-side\n\t  data = data.replace(rEscapedNewline, '\\\\\\n');\n\t  this.area.value = data.replace(rNewline, '\\\\n');\n\t\n\t  try {\n\t    this.form.submit();\n\t  } catch (e) {}\n\t\n\t  if (this.iframe.attachEvent) {\n\t    this.iframe.onreadystatechange = function () {\n\t      if (self.iframe.readyState === 'complete') {\n\t        complete();\n\t      }\n\t    };\n\t  } else {\n\t    this.iframe.onload = complete;\n\t  }\n\t};\n\t\n\t/* WEBPACK VAR INJECTION */}.call(exports, (function() { return this; }())))\n\n/***/ },\n\n/***/ 489:\n/***/ function(module, exports, __webpack_require__) {\n\n\t/* WEBPACK VAR INJECTION */(function(global) {/**\n\t * Module dependencies.\n\t */\n\t\n\tvar Transport = __webpack_require__(472);\n\tvar parser = __webpack_require__(473);\n\tvar parseqs = __webpack_require__(483);\n\tvar inherit = __webpack_require__(484);\n\tvar yeast = __webpack_require__(485);\n\tvar debug = __webpack_require__(486)('engine.io-client:websocket');\n\tvar BrowserWebSocket = global.WebSocket || global.MozWebSocket;\n\tvar NodeWebSocket;\n\tif (typeof window === 'undefined') {\n\t  try {\n\t    NodeWebSocket = __webpack_require__(490);\n\t  } catch (e) { }\n\t}\n\t\n\t/**\n\t * Get either the `WebSocket` or `MozWebSocket` globals\n\t * in the browser or try to resolve WebSocket-compatible\n\t * interface exposed by `ws` for Node-like environment.\n\t */\n\t\n\tvar WebSocket = BrowserWebSocket;\n\tif (!WebSocket && typeof window === 'undefined') {\n\t  WebSocket = NodeWebSocket;\n\t}\n\t\n\t/**\n\t * Module exports.\n\t */\n\t\n\tmodule.exports = WS;\n\t\n\t/**\n\t * WebSocket transport constructor.\n\t *\n\t * @api {Object} connection options\n\t * @api public\n\t */\n\t\n\tfunction WS (opts) {\n\t  var forceBase64 = (opts && opts.forceBase64);\n\t  if (forceBase64) {\n\t    this.supportsBinary = false;\n\t  }\n\t  this.perMessageDeflate = opts.perMessageDeflate;\n\t  this.usingBrowserWebSocket = BrowserWebSocket && !opts.forceNode;\n\t  if (!this.usingBrowserWebSocket) {\n\t    WebSocket = NodeWebSocket;\n\t  }\n\t  Transport.call(this, opts);\n\t}\n\t\n\t/**\n\t * Inherits from Transport.\n\t */\n\t\n\tinherit(WS, Transport);\n\t\n\t/**\n\t * Transport name.\n\t *\n\t * @api public\n\t */\n\t\n\tWS.prototype.name = 'websocket';\n\t\n\t/*\n\t * WebSockets support binary\n\t */\n\t\n\tWS.prototype.supportsBinary = true;\n\t\n\t/**\n\t * Opens socket.\n\t *\n\t * @api private\n\t */\n\t\n\tWS.prototype.doOpen = function () {\n\t  if (!this.check()) {\n\t    // let probe timeout\n\t    return;\n\t  }\n\t\n\t  var uri = this.uri();\n\t  var protocols = void (0);\n\t  var opts = {\n\t    agent: this.agent,\n\t    perMessageDeflate: this.perMessageDeflate\n\t  };\n\t\n\t  // SSL options for Node.js client\n\t  opts.pfx = this.pfx;\n\t  opts.key = this.key;\n\t  opts.passphrase = this.passphrase;\n\t  opts.cert = this.cert;\n\t  opts.ca = this.ca;\n\t  opts.ciphers = this.ciphers;\n\t  opts.rejectUnauthorized = this.rejectUnauthorized;\n\t  if (this.extraHeaders) {\n\t    opts.headers = this.extraHeaders;\n\t  }\n\t  if (this.localAddress) {\n\t    opts.localAddress = this.localAddress;\n\t  }\n\t\n\t  try {\n\t    this.ws = this.usingBrowserWebSocket ? new WebSocket(uri) : new WebSocket(uri, protocols, opts);\n\t  } catch (err) {\n\t    return this.emit('error', err);\n\t  }\n\t\n\t  if (this.ws.binaryType === undefined) {\n\t    this.supportsBinary = false;\n\t  }\n\t\n\t  if (this.ws.supports && this.ws.supports.binary) {\n\t    this.supportsBinary = true;\n\t    this.ws.binaryType = 'nodebuffer';\n\t  } else {\n\t    this.ws.binaryType = 'arraybuffer';\n\t  }\n\t\n\t  this.addEventListeners();\n\t};\n\t\n\t/**\n\t * Adds event listeners to the socket\n\t *\n\t * @api private\n\t */\n\t\n\tWS.prototype.addEventListeners = function () {\n\t  var self = this;\n\t\n\t  this.ws.onopen = function () {\n\t    self.onOpen();\n\t  };\n\t  this.ws.onclose = function () {\n\t    self.onClose();\n\t  };\n\t  this.ws.onmessage = function (ev) {\n\t    self.onData(ev.data);\n\t  };\n\t  this.ws.onerror = function (e) {\n\t    self.onError('websocket error', e);\n\t  };\n\t};\n\t\n\t/**\n\t * Writes data to socket.\n\t *\n\t * @param {Array} array of packets.\n\t * @api private\n\t */\n\t\n\tWS.prototype.write = function (packets) {\n\t  var self = this;\n\t  this.writable = false;\n\t\n\t  // encodePacket efficient as it uses WS framing\n\t  // no need for encodePayload\n\t  var total = packets.length;\n\t  for (var i = 0, l = total; i < l; i++) {\n\t    (function (packet) {\n\t      parser.encodePacket(packet, self.supportsBinary, function (data) {\n\t        if (!self.usingBrowserWebSocket) {\n\t          // always create a new object (GH-437)\n\t          var opts = {};\n\t          if (packet.options) {\n\t            opts.compress = packet.options.compress;\n\t          }\n\t\n\t          if (self.perMessageDeflate) {\n\t            var len = 'string' === typeof data ? global.Buffer.byteLength(data) : data.length;\n\t            if (len < self.perMessageDeflate.threshold) {\n\t              opts.compress = false;\n\t            }\n\t          }\n\t        }\n\t\n\t        // Sometimes the websocket has already been closed but the browser didn't\n\t        // have a chance of informing us about it yet, in that case send will\n\t        // throw an error\n\t        try {\n\t          if (self.usingBrowserWebSocket) {\n\t            // TypeError is thrown when passing the second argument on Safari\n\t            self.ws.send(data);\n\t          } else {\n\t            self.ws.send(data, opts);\n\t          }\n\t        } catch (e) {\n\t          debug('websocket closed before onclose event');\n\t        }\n\t\n\t        --total || done();\n\t      });\n\t    })(packets[i]);\n\t  }\n\t\n\t  function done () {\n\t    self.emit('flush');\n\t\n\t    // fake drain\n\t    // defer to next tick to allow Socket to clear writeBuffer\n\t    setTimeout(function () {\n\t      self.writable = true;\n\t      self.emit('drain');\n\t    }, 0);\n\t  }\n\t};\n\t\n\t/**\n\t * Called upon close\n\t *\n\t * @api private\n\t */\n\t\n\tWS.prototype.onClose = function () {\n\t  Transport.prototype.onClose.call(this);\n\t};\n\t\n\t/**\n\t * Closes socket.\n\t *\n\t * @api private\n\t */\n\t\n\tWS.prototype.doClose = function () {\n\t  if (typeof this.ws !== 'undefined') {\n\t    this.ws.close();\n\t  }\n\t};\n\t\n\t/**\n\t * Generates uri for connection.\n\t *\n\t * @api private\n\t */\n\t\n\tWS.prototype.uri = function () {\n\t  var query = this.query || {};\n\t  var schema = this.secure ? 'wss' : 'ws';\n\t  var port = '';\n\t\n\t  // avoid port if default for schema\n\t  if (this.port && (('wss' === schema && Number(this.port) !== 443) ||\n\t    ('ws' === schema && Number(this.port) !== 80))) {\n\t    port = ':' + this.port;\n\t  }\n\t\n\t  // append timestamp to URI\n\t  if (this.timestampRequests) {\n\t    query[this.timestampParam] = yeast();\n\t  }\n\t\n\t  // communicate binary support capabilities\n\t  if (!this.supportsBinary) {\n\t    query.b64 = 1;\n\t  }\n\t\n\t  query = parseqs.encode(query);\n\t\n\t  // prepend ? to query\n\t  if (query.length) {\n\t    query = '?' + query;\n\t  }\n\t\n\t  var ipv6 = this.hostname.indexOf(':') !== -1;\n\t  return schema + '://' + (ipv6 ? '[' + this.hostname + ']' : this.hostname) + port + this.path + query;\n\t};\n\t\n\t/**\n\t * Feature detection for WebSocket.\n\t *\n\t * @return {Boolean} whether this transport is available.\n\t * @api public\n\t */\n\t\n\tWS.prototype.check = function () {\n\t  return !!WebSocket && !('__initialize' in WebSocket && this.name === WS.prototype.name);\n\t};\n\t\n\t/* WEBPACK VAR INJECTION */}.call(exports, (function() { return this; }())))\n\n/***/ },\n\n/***/ 490:\n/***/ function(module, exports) {\n\n\t/* (ignored) */\n\n/***/ },\n\n/***/ 491:\n/***/ function(module, exports) {\n\n\t\n\tvar indexOf = [].indexOf;\n\t\n\tmodule.exports = function(arr, obj){\n\t  if (indexOf) return arr.indexOf(obj);\n\t  for (var i = 0; i < arr.length; ++i) {\n\t    if (arr[i] === obj) return i;\n\t  }\n\t  return -1;\n\t};\n\n/***/ },\n\n/***/ 492:\n/***/ function(module, exports) {\n\n\t/* WEBPACK VAR INJECTION */(function(global) {/**\r\n\t * JSON parse.\r\n\t *\r\n\t * @see Based on jQuery#parseJSON (MIT) and JSON2\r\n\t * @api private\r\n\t */\r\n\t\r\n\tvar rvalidchars = /^[\\],:{}\\s]*$/;\r\n\tvar rvalidescape = /\\\\(?:[\"\\\\\\/bfnrt]|u[0-9a-fA-F]{4})/g;\r\n\tvar rvalidtokens = /\"[^\"\\\\\\n\\r]*\"|true|false|null|-?\\d+(?:\\.\\d*)?(?:[eE][+\\-]?\\d+)?/g;\r\n\tvar rvalidbraces = /(?:^|:|,)(?:\\s*\\[)+/g;\r\n\tvar rtrimLeft = /^\\s+/;\r\n\tvar rtrimRight = /\\s+$/;\r\n\t\r\n\tmodule.exports = function parsejson(data) {\r\n\t  if ('string' != typeof data || !data) {\r\n\t    return null;\r\n\t  }\r\n\t\r\n\t  data = data.replace(rtrimLeft, '').replace(rtrimRight, '');\r\n\t\r\n\t  // Attempt to parse using the native JSON parser first\r\n\t  if (global.JSON && JSON.parse) {\r\n\t    return JSON.parse(data);\r\n\t  }\r\n\t\r\n\t  if (rvalidchars.test(data.replace(rvalidescape, '@')\r\n\t      .replace(rvalidtokens, ']')\r\n\t      .replace(rvalidbraces, ''))) {\r\n\t    return (new Function('return ' + data))();\r\n\t  }\r\n\t};\n\t/* WEBPACK VAR INJECTION */}.call(exports, (function() { return this; }())))\n\n/***/ },\n\n/***/ 493:\n/***/ function(module, exports, __webpack_require__) {\n\n\t\n\t/**\n\t * Module dependencies.\n\t */\n\t\n\tvar parser = __webpack_require__(452);\n\tvar Emitter = __webpack_require__(494);\n\tvar toArray = __webpack_require__(495);\n\tvar on = __webpack_require__(496);\n\tvar bind = __webpack_require__(497);\n\tvar debug = __webpack_require__(449)('socket.io-client:socket');\n\tvar hasBin = __webpack_require__(475);\n\t\n\t/**\n\t * Module exports.\n\t */\n\t\n\tmodule.exports = exports = Socket;\n\t\n\t/**\n\t * Internal events (blacklisted).\n\t * These events can't be emitted by the user.\n\t *\n\t * @api private\n\t */\n\t\n\tvar events = {\n\t  connect: 1,\n\t  connect_error: 1,\n\t  connect_timeout: 1,\n\t  connecting: 1,\n\t  disconnect: 1,\n\t  error: 1,\n\t  reconnect: 1,\n\t  reconnect_attempt: 1,\n\t  reconnect_failed: 1,\n\t  reconnect_error: 1,\n\t  reconnecting: 1,\n\t  ping: 1,\n\t  pong: 1\n\t};\n\t\n\t/**\n\t * Shortcut to `Emitter#emit`.\n\t */\n\t\n\tvar emit = Emitter.prototype.emit;\n\t\n\t/**\n\t * `Socket` constructor.\n\t *\n\t * @api public\n\t */\n\t\n\tfunction Socket (io, nsp, opts) {\n\t  this.io = io;\n\t  this.nsp = nsp;\n\t  this.json = this; // compat\n\t  this.ids = 0;\n\t  this.acks = {};\n\t  this.receiveBuffer = [];\n\t  this.sendBuffer = [];\n\t  this.connected = false;\n\t  this.disconnected = true;\n\t  if (opts && opts.query) {\n\t    this.query = opts.query;\n\t  }\n\t  if (this.io.autoConnect) this.open();\n\t}\n\t\n\t/**\n\t * Mix in `Emitter`.\n\t */\n\t\n\tEmitter(Socket.prototype);\n\t\n\t/**\n\t * Subscribe to open, close and packet events\n\t *\n\t * @api private\n\t */\n\t\n\tSocket.prototype.subEvents = function () {\n\t  if (this.subs) return;\n\t\n\t  var io = this.io;\n\t  this.subs = [\n\t    on(io, 'open', bind(this, 'onopen')),\n\t    on(io, 'packet', bind(this, 'onpacket')),\n\t    on(io, 'close', bind(this, 'onclose'))\n\t  ];\n\t};\n\t\n\t/**\n\t * \"Opens\" the socket.\n\t *\n\t * @api public\n\t */\n\t\n\tSocket.prototype.open =\n\tSocket.prototype.connect = function () {\n\t  if (this.connected) return this;\n\t\n\t  this.subEvents();\n\t  this.io.open(); // ensure open\n\t  if ('open' === this.io.readyState) this.onopen();\n\t  this.emit('connecting');\n\t  return this;\n\t};\n\t\n\t/**\n\t * Sends a `message` event.\n\t *\n\t * @return {Socket} self\n\t * @api public\n\t */\n\t\n\tSocket.prototype.send = function () {\n\t  var args = toArray(arguments);\n\t  args.unshift('message');\n\t  this.emit.apply(this, args);\n\t  return this;\n\t};\n\t\n\t/**\n\t * Override `emit`.\n\t * If the event is in `events`, it's emitted normally.\n\t *\n\t * @param {String} event name\n\t * @return {Socket} self\n\t * @api public\n\t */\n\t\n\tSocket.prototype.emit = function (ev) {\n\t  if (events.hasOwnProperty(ev)) {\n\t    emit.apply(this, arguments);\n\t    return this;\n\t  }\n\t\n\t  var args = toArray(arguments);\n\t  var parserType = parser.EVENT; // default\n\t  if (hasBin(args)) { parserType = parser.BINARY_EVENT; } // binary\n\t  var packet = { type: parserType, data: args };\n\t\n\t  packet.options = {};\n\t  packet.options.compress = !this.flags || false !== this.flags.compress;\n\t\n\t  // event ack callback\n\t  if ('function' === typeof args[args.length - 1]) {\n\t    debug('emitting packet with ack id %d', this.ids);\n\t    this.acks[this.ids] = args.pop();\n\t    packet.id = this.ids++;\n\t  }\n\t\n\t  if (this.connected) {\n\t    this.packet(packet);\n\t  } else {\n\t    this.sendBuffer.push(packet);\n\t  }\n\t\n\t  delete this.flags;\n\t\n\t  return this;\n\t};\n\t\n\t/**\n\t * Sends a packet.\n\t *\n\t * @param {Object} packet\n\t * @api private\n\t */\n\t\n\tSocket.prototype.packet = function (packet) {\n\t  packet.nsp = this.nsp;\n\t  this.io.packet(packet);\n\t};\n\t\n\t/**\n\t * Called upon engine `open`.\n\t *\n\t * @api private\n\t */\n\t\n\tSocket.prototype.onopen = function () {\n\t  debug('transport is open - connecting');\n\t\n\t  // write connect packet if necessary\n\t  if ('/' !== this.nsp) {\n\t    if (this.query) {\n\t      this.packet({type: parser.CONNECT, query: this.query});\n\t    } else {\n\t      this.packet({type: parser.CONNECT});\n\t    }\n\t  }\n\t};\n\t\n\t/**\n\t * Called upon engine `close`.\n\t *\n\t * @param {String} reason\n\t * @api private\n\t */\n\t\n\tSocket.prototype.onclose = function (reason) {\n\t  debug('close (%s)', reason);\n\t  this.connected = false;\n\t  this.disconnected = true;\n\t  delete this.id;\n\t  this.emit('disconnect', reason);\n\t};\n\t\n\t/**\n\t * Called with socket packet.\n\t *\n\t * @param {Object} packet\n\t * @api private\n\t */\n\t\n\tSocket.prototype.onpacket = function (packet) {\n\t  if (packet.nsp !== this.nsp) return;\n\t\n\t  switch (packet.type) {\n\t    case parser.CONNECT:\n\t      this.onconnect();\n\t      break;\n\t\n\t    case parser.EVENT:\n\t      this.onevent(packet);\n\t      break;\n\t\n\t    case parser.BINARY_EVENT:\n\t      this.onevent(packet);\n\t      break;\n\t\n\t    case parser.ACK:\n\t      this.onack(packet);\n\t      break;\n\t\n\t    case parser.BINARY_ACK:\n\t      this.onack(packet);\n\t      break;\n\t\n\t    case parser.DISCONNECT:\n\t      this.ondisconnect();\n\t      break;\n\t\n\t    case parser.ERROR:\n\t      this.emit('error', packet.data);\n\t      break;\n\t  }\n\t};\n\t\n\t/**\n\t * Called upon a server event.\n\t *\n\t * @param {Object} packet\n\t * @api private\n\t */\n\t\n\tSocket.prototype.onevent = function (packet) {\n\t  var args = packet.data || [];\n\t  debug('emitting event %j', args);\n\t\n\t  if (null != packet.id) {\n\t    debug('attaching ack callback to event');\n\t    args.push(this.ack(packet.id));\n\t  }\n\t\n\t  if (this.connected) {\n\t    emit.apply(this, args);\n\t  } else {\n\t    this.receiveBuffer.push(args);\n\t  }\n\t};\n\t\n\t/**\n\t * Produces an ack callback to emit with an event.\n\t *\n\t * @api private\n\t */\n\t\n\tSocket.prototype.ack = function (id) {\n\t  var self = this;\n\t  var sent = false;\n\t  return function () {\n\t    // prevent double callbacks\n\t    if (sent) return;\n\t    sent = true;\n\t    var args = toArray(arguments);\n\t    debug('sending ack %j', args);\n\t\n\t    var type = hasBin(args) ? parser.BINARY_ACK : parser.ACK;\n\t    self.packet({\n\t      type: type,\n\t      id: id,\n\t      data: args\n\t    });\n\t  };\n\t};\n\t\n\t/**\n\t * Called upon a server acknowlegement.\n\t *\n\t * @param {Object} packet\n\t * @api private\n\t */\n\t\n\tSocket.prototype.onack = function (packet) {\n\t  var ack = this.acks[packet.id];\n\t  if ('function' === typeof ack) {\n\t    debug('calling ack %s with %j', packet.id, packet.data);\n\t    ack.apply(this, packet.data);\n\t    delete this.acks[packet.id];\n\t  } else {\n\t    debug('bad ack %s', packet.id);\n\t  }\n\t};\n\t\n\t/**\n\t * Called upon server connect.\n\t *\n\t * @api private\n\t */\n\t\n\tSocket.prototype.onconnect = function () {\n\t  this.connected = true;\n\t  this.disconnected = false;\n\t  this.emit('connect');\n\t  this.emitBuffered();\n\t};\n\t\n\t/**\n\t * Emit buffered events (received and emitted).\n\t *\n\t * @api private\n\t */\n\t\n\tSocket.prototype.emitBuffered = function () {\n\t  var i;\n\t  for (i = 0; i < this.receiveBuffer.length; i++) {\n\t    emit.apply(this, this.receiveBuffer[i]);\n\t  }\n\t  this.receiveBuffer = [];\n\t\n\t  for (i = 0; i < this.sendBuffer.length; i++) {\n\t    this.packet(this.sendBuffer[i]);\n\t  }\n\t  this.sendBuffer = [];\n\t};\n\t\n\t/**\n\t * Called upon server disconnect.\n\t *\n\t * @api private\n\t */\n\t\n\tSocket.prototype.ondisconnect = function () {\n\t  debug('server disconnect (%s)', this.nsp);\n\t  this.destroy();\n\t  this.onclose('io server disconnect');\n\t};\n\t\n\t/**\n\t * Called upon forced client/server side disconnections,\n\t * this method ensures the manager stops tracking us and\n\t * that reconnections don't get triggered for this.\n\t *\n\t * @api private.\n\t */\n\t\n\tSocket.prototype.destroy = function () {\n\t  if (this.subs) {\n\t    // clean subscriptions to avoid reconnections\n\t    for (var i = 0; i < this.subs.length; i++) {\n\t      this.subs[i].destroy();\n\t    }\n\t    this.subs = null;\n\t  }\n\t\n\t  this.io.destroy(this);\n\t};\n\t\n\t/**\n\t * Disconnects the socket manually.\n\t *\n\t * @return {Socket} self\n\t * @api public\n\t */\n\t\n\tSocket.prototype.close =\n\tSocket.prototype.disconnect = function () {\n\t  if (this.connected) {\n\t    debug('performing disconnect (%s)', this.nsp);\n\t    this.packet({ type: parser.DISCONNECT });\n\t  }\n\t\n\t  // remove socket from pool\n\t  this.destroy();\n\t\n\t  if (this.connected) {\n\t    // fire events\n\t    this.onclose('io client disconnect');\n\t  }\n\t  return this;\n\t};\n\t\n\t/**\n\t * Sets the compress flag.\n\t *\n\t * @param {Boolean} if `true`, compresses the sending data\n\t * @return {Socket} self\n\t * @api public\n\t */\n\t\n\tSocket.prototype.compress = function (compress) {\n\t  this.flags = this.flags || {};\n\t  this.flags.compress = compress;\n\t  return this;\n\t};\n\n\n/***/ },\n\n/***/ 494:\n482,\n\n/***/ 495:\n/***/ function(module, exports) {\n\n\tmodule.exports = toArray\n\t\n\tfunction toArray(list, index) {\n\t    var array = []\n\t\n\t    index = index || 0\n\t\n\t    for (var i = index || 0; i < list.length; i++) {\n\t        array[i - index] = list[i]\n\t    }\n\t\n\t    return array\n\t}\n\n\n/***/ },\n\n/***/ 496:\n/***/ function(module, exports) {\n\n\t\n\t/**\n\t * Module exports.\n\t */\n\t\n\tmodule.exports = on;\n\t\n\t/**\n\t * Helper for subscriptions.\n\t *\n\t * @param {Object|EventEmitter} obj with `Emitter` mixin or `EventEmitter`\n\t * @param {String} event name\n\t * @param {Function} callback\n\t * @api public\n\t */\n\t\n\tfunction on (obj, ev, fn) {\n\t  obj.on(ev, fn);\n\t  return {\n\t    destroy: function () {\n\t      obj.removeListener(ev, fn);\n\t    }\n\t  };\n\t}\n\n\n/***/ },\n\n/***/ 497:\n/***/ function(module, exports) {\n\n\t/**\n\t * Slice reference.\n\t */\n\t\n\tvar slice = [].slice;\n\t\n\t/**\n\t * Bind `obj` to `fn`.\n\t *\n\t * @param {Object} obj\n\t * @param {Function|String} fn or string\n\t * @return {Function}\n\t * @api public\n\t */\n\t\n\tmodule.exports = function(obj, fn){\n\t  if ('string' == typeof fn) fn = obj[fn];\n\t  if ('function' != typeof fn) throw new Error('bind() requires a function');\n\t  var args = slice.call(arguments, 2);\n\t  return function(){\n\t    return fn.apply(obj, args.concat(slice.call(arguments)));\n\t  }\n\t};\n\n\n/***/ },\n\n/***/ 498:\n/***/ function(module, exports) {\n\n\t\n\t/**\n\t * Expose `Backoff`.\n\t */\n\t\n\tmodule.exports = Backoff;\n\t\n\t/**\n\t * Initialize backoff timer with `opts`.\n\t *\n\t * - `min` initial timeout in milliseconds [100]\n\t * - `max` max timeout [10000]\n\t * - `jitter` [0]\n\t * - `factor` [2]\n\t *\n\t * @param {Object} opts\n\t * @api public\n\t */\n\t\n\tfunction Backoff(opts) {\n\t  opts = opts || {};\n\t  this.ms = opts.min || 100;\n\t  this.max = opts.max || 10000;\n\t  this.factor = opts.factor || 2;\n\t  this.jitter = opts.jitter > 0 && opts.jitter <= 1 ? opts.jitter : 0;\n\t  this.attempts = 0;\n\t}\n\t\n\t/**\n\t * Return the backoff duration.\n\t *\n\t * @return {Number}\n\t * @api public\n\t */\n\t\n\tBackoff.prototype.duration = function(){\n\t  var ms = this.ms * Math.pow(this.factor, this.attempts++);\n\t  if (this.jitter) {\n\t    var rand =  Math.random();\n\t    var deviation = Math.floor(rand * this.jitter * ms);\n\t    ms = (Math.floor(rand * 10) & 1) == 0  ? ms - deviation : ms + deviation;\n\t  }\n\t  return Math.min(ms, this.max) | 0;\n\t};\n\t\n\t/**\n\t * Reset the number of attempts.\n\t *\n\t * @api public\n\t */\n\t\n\tBackoff.prototype.reset = function(){\n\t  this.attempts = 0;\n\t};\n\t\n\t/**\n\t * Set the minimum duration\n\t *\n\t * @api public\n\t */\n\t\n\tBackoff.prototype.setMin = function(min){\n\t  this.ms = min;\n\t};\n\t\n\t/**\n\t * Set the maximum duration\n\t *\n\t * @api public\n\t */\n\t\n\tBackoff.prototype.setMax = function(max){\n\t  this.max = max;\n\t};\n\t\n\t/**\n\t * Set the jitter\n\t *\n\t * @api public\n\t */\n\t\n\tBackoff.prototype.setJitter = function(jitter){\n\t  this.jitter = jitter;\n\t};\n\t\n\n\n/***/ },\n\n/***/ 499:\n/***/ function(module, exports, __webpack_require__) {\n\n\t\"use strict\";\n\tvar __extends = (this && this.__extends) || function (d, b) {\n\t    for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];\n\t    function __() { this.constructor = d; }\n\t    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());\n\t};\n\tvar __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {\n\t    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;\n\t    if (typeof Reflect === \"object\" && typeof Reflect.decorate === \"function\") r = Reflect.decorate(decorators, target, key, desc);\n\t    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;\n\t    return c > 3 && r && Object.defineProperty(target, key, r), r;\n\t};\n\tvar __metadata = (this && this.__metadata) || function (k, v) {\n\t    if (typeof Reflect === \"object\" && typeof Reflect.metadata === \"function\") return Reflect.metadata(k, v);\n\t};\n\tvar core_1 = __webpack_require__(3);\n\tvar base_output_sensor_1 = __webpack_require__(500);\n\tvar device_widget_service_1 = __webpack_require__(445);\n\tvar ServoWidgetComponent = (function (_super) {\n\t    __extends(ServoWidgetComponent, _super);\n\t    function ServoWidgetComponent(sensorWidgetService) {\n\t        _super.call(this, sensorWidgetService);\n\t    }\n\t    ServoWidgetComponent.prototype.changeDegree = function () {\n\t        return this.pushEvent(true, this.data.value);\n\t    };\n\t    __decorate([\n\t        core_1.Input(), \n\t        __metadata('design:type', Object)\n\t    ], ServoWidgetComponent.prototype, \"device\", void 0);\n\t    ServoWidgetComponent = __decorate([\n\t        core_1.Component({\n\t            selector: 'sh-servo-widget',\n\t            template: __webpack_require__(502),\n\t            styles: [\n\t                __webpack_require__(444),\n\t                __webpack_require__(503)\n\t            ]\n\t        }), \n\t        __metadata('design:paramtypes', [(typeof (_a = typeof device_widget_service_1.DeviceWidgetService !== 'undefined' && device_widget_service_1.DeviceWidgetService) === 'function' && _a) || Object])\n\t    ], ServoWidgetComponent);\n\t    return ServoWidgetComponent;\n\t    var _a;\n\t}(base_output_sensor_1.BaseOutputSensor));\n\texports.ServoWidgetComponent = ServoWidgetComponent;\n\n\n/***/ },\n\n/***/ 500:\n/***/ function(module, exports, __webpack_require__) {\n\n\t\"use strict\";\n\tvar __extends = (this && this.__extends) || function (d, b) {\n\t    for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];\n\t    function __() { this.constructor = d; }\n\t    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());\n\t};\n\tvar base_sensor_1 = __webpack_require__(501);\n\texports.DEVICE_ON_STATE = 'ON';\n\texports.DEVICE_OFF_STATE = 'OFF';\n\texports.DEVICE_RESPOND_TIMEOUT = 1000;\n\tvar pending = Symbol('pending');\n\tvar timeout = Symbol('timeout');\n\tvar BaseOutputSensor = (function (_super) {\n\t    __extends(BaseOutputSensor, _super);\n\t    function BaseOutputSensor(sensorWidgetService) {\n\t        _super.call(this, sensorWidgetService);\n\t        this[pending] = null;\n\t    }\n\t    BaseOutputSensor.getConditionResult = function (condition, self, args) {\n\t        var isFunction = function (f) { return typeof f === 'function'; };\n\t        return isFunction(condition) ? condition.apply(self, args) : condition;\n\t    };\n\t    BaseOutputSensor.generateValue = function (condition, positiveValue, negativeValue, self, args) {\n\t        if (negativeValue === void 0) { negativeValue = null; }\n\t        return BaseOutputSensor.getConditionResult(condition, self, args) ? positiveValue : negativeValue;\n\t    };\n\t    BaseOutputSensor.prototype.toDeviceRepresentation = function (value) {\n\t        return value;\n\t    };\n\t    BaseOutputSensor.prototype.fromDeviceRepresentation = function (value) {\n\t        return value;\n\t    };\n\t    BaseOutputSensor.prototype.onDeviceDataChanged = function (data) {\n\t        // NOTE: mqtt is slow and sends us false information for some time after toggle\n\t        // we just don`t listen to socket (and mqtt) for some time to let it switch state\n\t        if (this[pending] !== null) {\n\t            return;\n\t        }\n\t        if (this.device.mqttId === data.device) {\n\t            var rawValue = BaseOutputSensor.generateValue(true, data.value);\n\t            this.data.value = this.fromDeviceRepresentation(rawValue);\n\t            this.data.updateTime = new Date();\n\t        }\n\t    };\n\t    BaseOutputSensor.prototype.pushEvent = function (condition, positiveValue, negativeValue, self, args) {\n\t        var _this = this;\n\t        if (negativeValue === void 0) { negativeValue = null; }\n\t        this[pending] = true;\n\t        clearTimeout(this[timeout]);\n\t        this[timeout] = setTimeout(function () {\n\t            _this[pending] = null;\n\t        }, exports.DEVICE_RESPOND_TIMEOUT);\n\t        this.data.value = BaseOutputSensor.generateValue(condition, positiveValue, negativeValue, self, args);\n\t        this.data.updateTime = new Date();\n\t        this.sensorWidgetService.pushEvent({\n\t            device: this.device.mqttId,\n\t            value: this.toDeviceRepresentation(this.data.value)\n\t        });\n\t    };\n\t    return BaseOutputSensor;\n\t}(base_sensor_1.BaseSensor));\n\texports.BaseOutputSensor = BaseOutputSensor;\n\n\n/***/ },\n\n/***/ 501:\n/***/ function(module, exports) {\n\n\t\"use strict\";\n\tvar BaseSensor = (function () {\n\t    function BaseSensor(sensorWidgetService) {\n\t        this.sensorWidgetService = sensorWidgetService;\n\t    }\n\t    BaseSensor.prototype.ngOnInit = function () {\n\t        var _this = this;\n\t        this.data = {\n\t            value: this.device.value || null,\n\t            updateTime: this.device.valueUpdated ? new Date(this.device.valueUpdated) : null\n\t        };\n\t        this.sensorWidgetService\n\t            .subscribe(this.device.mqttId, function (data) { return _this.onDeviceDataChanged(data); });\n\t    };\n\t    BaseSensor.prototype.onDeviceDataChanged = function (data) {\n\t        if (this.device.mqttId === data.device) {\n\t            this.data = data;\n\t            this.data.updateTime = new Date();\n\t        }\n\t    };\n\t    BaseSensor.prototype.ngOnDestroy = function () {\n\t        this.sensorWidgetService\n\t            .unsubscribe(this.device.mqttId);\n\t    };\n\t    return BaseSensor;\n\t}());\n\texports.BaseSensor = BaseSensor;\n\n\n/***/ },\n\n/***/ 502:\n/***/ function(module, exports) {\n\n\tmodule.exports = \"<div class=\\\"sensor-widget_info\\\">\\n    <div class=\\\"sensor-widget_info_value\\\">\\n        <div class=\\\"sensor-servo-widget_label\\\">\\n            <div class=\\\"sensor-servo-widget_label-left\\\">0</div>\\n            <div class=\\\"sensor-servo-widget_label-right\\\">180</div>\\n        </div>\\n        <input class=\\\"sensor-servo-widget_controller\\\" type=\\\"range\\\" [min]=\\\"0\\\" [max]=\\\"180\\\" [(ngModel)]=\\\"data.value\\\"\\n               (change)=\\\"changeDegree()\\\">\\n\\n        <div class=\\\"sensor-servo-widget_value_wrap\\\">\\n            <span [hidden]=\\\"data.value===undefined\\\">{{data.value}} {{device.metrics}}</span>\\n        </div>\\n    </div>\\n</div>\\n<div class=\\\"sensor-widget_footer\\\"\\n     [hidden]=\\\"data.updateTime===undefined\\\">\\n    {{data.updateTime | date:\\\"MM.dd.y HH:mm:ss\\\" }}\\n</div>\\n\"\n\n/***/ },\n\n/***/ 503:\n/***/ function(module, exports) {\n\n\tmodule.exports = \".sensor-servo-widget_label{font-size:10px;margin-bottom:12px;font-weight:normal;position:relative;top:12px}.sensor-servo-widget_label-left{float:left}.sensor-servo-widget_label-right{float:right}.sensor-servo-widget_label:after{clear:both}.sensor-servo-widget_value_wrap{overflow:hidden;white-space:nowrap;text-overflow:ellipsis;font-size:20px}.sensor-widget_info input[type=range]{-webkit-appearance:none;width:100%;background:transparent;border-color:transparent;color:transparent;margin:0 0 10px 0}.sensor-widget_info input[type=range]::-webkit-slider-thumb{-webkit-appearance:none;width:29px;height:29px;border-radius:29px;background-color:#ffffff;margin-top:-14px;box-shadow:0 4px 8px 0 rgba(0,0,0,0.19);border:solid 0.5px rgba(0,0,0,0.1);cursor:pointer}.sensor-widget_info input[type=range]::-moz-range-thumb{width:29px;height:29px;border-radius:29px;background-color:#ffffff;margin-top:-14px;box-shadow:0 4px 8px 0 rgba(0,0,0,0.19);border:solid 0.5px rgba(0,0,0,0.1);cursor:pointer}.sensor-widget_info input[type=range]::-ms-thumb{width:29px;height:29px;border-radius:29px;background-color:#ffffff;margin-top:-14px;box-shadow:0 4px 8px 0 rgba(0,0,0,0.19);border:solid 0.5px rgba(0,0,0,0.1);cursor:pointer}\\n\"\n\n/***/ },\n\n/***/ 504:\n/***/ function(module, exports, __webpack_require__) {\n\n\t\"use strict\";\n\tvar __extends = (this && this.__extends) || function (d, b) {\n\t    for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];\n\t    function __() { this.constructor = d; }\n\t    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());\n\t};\n\tvar __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {\n\t    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;\n\t    if (typeof Reflect === \"object\" && typeof Reflect.decorate === \"function\") r = Reflect.decorate(decorators, target, key, desc);\n\t    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;\n\t    return c > 3 && r && Object.defineProperty(target, key, r), r;\n\t};\n\tvar __metadata = (this && this.__metadata) || function (k, v) {\n\t    if (typeof Reflect === \"object\" && typeof Reflect.metadata === \"function\") return Reflect.metadata(k, v);\n\t};\n\tvar core_1 = __webpack_require__(3);\n\tvar base_output_sensor_1 = __webpack_require__(500);\n\tvar device_widget_service_1 = __webpack_require__(445);\n\tvar SwitcherWidgetComponent = (function (_super) {\n\t    __extends(SwitcherWidgetComponent, _super);\n\t    function SwitcherWidgetComponent(sensorWidgetService) {\n\t        _super.call(this, sensorWidgetService);\n\t    }\n\t    SwitcherWidgetComponent.prototype.fromDeviceRepresentation = function (value) {\n\t        return value === base_output_sensor_1.DEVICE_ON_STATE;\n\t    };\n\t    SwitcherWidgetComponent.prototype.switchExecutor = function ($event) {\n\t        return this.pushEvent($event.target.checked, base_output_sensor_1.DEVICE_ON_STATE, base_output_sensor_1.DEVICE_OFF_STATE);\n\t    };\n\t    __decorate([\n\t        core_1.Input(), \n\t        __metadata('design:type', Object)\n\t    ], SwitcherWidgetComponent.prototype, \"device\", void 0);\n\t    SwitcherWidgetComponent = __decorate([\n\t        core_1.Component({\n\t            selector: 'sh-switcher-widget',\n\t            template: __webpack_require__(505),\n\t            styles: [\n\t                __webpack_require__(506),\n\t                __webpack_require__(444)\n\t            ]\n\t        }), \n\t        __metadata('design:paramtypes', [(typeof (_a = typeof device_widget_service_1.DeviceWidgetService !== 'undefined' && device_widget_service_1.DeviceWidgetService) === 'function' && _a) || Object])\n\t    ], SwitcherWidgetComponent);\n\t    return SwitcherWidgetComponent;\n\t    var _a;\n\t}(base_output_sensor_1.BaseOutputSensor));\n\texports.SwitcherWidgetComponent = SwitcherWidgetComponent;\n\n\n/***/ },\n\n/***/ 505:\n/***/ function(module, exports) {\n\n\tmodule.exports = \"<div class=\\\"sensor-widget_switcher-info\\\">\\n    <div class=\\\"sensor-widget_info_value\\\">\\n        <div class=\\\"sh-switch\\\">\\n            <label>\\n                <input type=\\\"checkbox\\\"\\n                       [(ngModel)]=\\\"data.value\\\"\\n                       (change)=\\\"switchExecutor($event)\\\">\\n                <span class=\\\"sh-lever\\\"></span>\\n            </label>\\n        </div>\\n        <div class=\\\"sensor-widget_info_value--wrap\\\">\\n            <span [hidden]=\\\"data.value===undefined\\\">{{data.value ? 'ON': 'OFF'}}</span>\\n        </div>\\n    </div>\\n</div>\\n<div class=\\\"sensor-widget_footer\\\"\\n     [hidden]=\\\"data.updateTime===undefined\\\">\\n    {{data.updateTime | date:\\\"MM.dd.y HH:mm:ss\\\" }}\\n</div>\\n\"\n\n/***/ },\n\n/***/ 506:\n/***/ function(module, exports) {\n\n\tmodule.exports = \".sh-switch,.sh-switch *{-webkit-user-select:none;-moz-user-select:none;-khtml-user-select:none;-ms-user-select:none}.sh-switch label{cursor:pointer}.sh-switch label input[type=checkbox]+.sh-lever{background-color:#fff}.sh-switch label input[type=checkbox]{opacity:0;width:0;height:0}.sh-switch label input[type=checkbox]:checked+.sh-lever{background-color:#9AC352}.sh-switch label input[type=checkbox]:checked+.sh-lever:after{background-color:#FFFFFF;left:2px;top:2px}.sh-switch label .sh-lever{content:\\\"\\\";display:inline-block;position:relative;width:33px;height:58px;background-color:#FFFFFF;border-radius:16px;margin-right:10px;transition:background 0.3s ease;vertical-align:middle;margin:12px 0}.sh-switch label .sh-lever:after{content:\\\"\\\";position:absolute;display:inline-block;width:29px;height:29px;border-radius:29px;box-shadow:0 1px 3px 1px rgba(0,0,0,0.19);left:2px;top:27px;transition:left 0.3s ease, background .3s ease, box-shadow 0.1s ease}input[type=checkbox]:checked:not(:disabled) ~ .sh-lever:active::after,input[type=checkbox]:checked:not(:disabled).tabbed:focus ~ .sh-lever::after{box-shadow:0 1px 3px 1px rgba(0,0,0,0.4),0 0 0 15px rgba(154,195,82,0.1)}input[type=checkbox]:not(:disabled) ~ .sh-lever:active:after,input[type=checkbox]:not(:disabled).tabbed:focus ~ .sh-lever::after{box-shadow:0 1px 3px 1px rgba(0,0,0,0.4),0 0 0 15px rgba(0,0,0,0.08)}.switch input[type=checkbox][disabled]+.sh-lever{cursor:default}.switch label input[type=checkbox][disabled]+.sh-lever:after,.switch label input[type=checkbox][disabled]:checked+.sh-lever:after{background-color:#777}\\n\"\n\n/***/ },\n\n/***/ 507:\n/***/ function(module, exports, __webpack_require__) {\n\n\t\"use strict\";\n\tvar __extends = (this && this.__extends) || function (d, b) {\n\t    for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];\n\t    function __() { this.constructor = d; }\n\t    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());\n\t};\n\tvar __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {\n\t    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;\n\t    if (typeof Reflect === \"object\" && typeof Reflect.decorate === \"function\") r = Reflect.decorate(decorators, target, key, desc);\n\t    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;\n\t    return c > 3 && r && Object.defineProperty(target, key, r), r;\n\t};\n\tvar __metadata = (this && this.__metadata) || function (k, v) {\n\t    if (typeof Reflect === \"object\" && typeof Reflect.metadata === \"function\") return Reflect.metadata(k, v);\n\t};\n\tvar core_1 = __webpack_require__(3);\n\tvar device_widget_service_1 = __webpack_require__(445);\n\tvar base_sensor_1 = __webpack_require__(501);\n\tvar SensorWidgetComponent = (function (_super) {\n\t    __extends(SensorWidgetComponent, _super);\n\t    function SensorWidgetComponent(sensorWidgetService) {\n\t        _super.call(this, sensorWidgetService);\n\t    }\n\t    __decorate([\n\t        core_1.Input(), \n\t        __metadata('design:type', Object)\n\t    ], SensorWidgetComponent.prototype, \"device\", void 0);\n\t    SensorWidgetComponent = __decorate([\n\t        core_1.Component({\n\t            selector: 'sh-sensor-widget',\n\t            template: __webpack_require__(508),\n\t            styles: [\n\t                __webpack_require__(444)\n\t            ]\n\t        }), \n\t        __metadata('design:paramtypes', [(typeof (_a = typeof device_widget_service_1.DeviceWidgetService !== 'undefined' && device_widget_service_1.DeviceWidgetService) === 'function' && _a) || Object])\n\t    ], SensorWidgetComponent);\n\t    return SensorWidgetComponent;\n\t    var _a;\n\t}(base_sensor_1.BaseSensor));\n\texports.SensorWidgetComponent = SensorWidgetComponent;\n\n\n/***/ },\n\n/***/ 508:\n/***/ function(module, exports) {\n\n\tmodule.exports = \"<div class=\\\"sensor-widget_info\\\">\\n    <div class=\\\"sensor-widget_info_value\\\">\\n        <span [hidden]=\\\"data.value===undefined\\\">{{data.value}} {{device.metrics}}</span>\\n        <span [hidden]=\\\"data.value\\\">.</span>\\n    </div>\\n</div>\\n<div class=\\\"sensor-widget_footer\\\"\\n     [hidden]=\\\"data.updateTime===undefined\\\">\\n    {{data.updateTime | date:\\\"MM.dd.y HH:mm:ss\\\" }}\\n</div>\\n\"\n\n/***/ },\n\n/***/ 562:\n/***/ function(module, exports, __webpack_require__) {\n\n\t\"use strict\";\n\tvar __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {\n\t    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;\n\t    if (typeof Reflect === \"object\" && typeof Reflect.decorate === \"function\") r = Reflect.decorate(decorators, target, key, desc);\n\t    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;\n\t    return c > 3 && r && Object.defineProperty(target, key, r), r;\n\t};\n\tvar __metadata = (this && this.__metadata) || function (k, v) {\n\t    if (typeof Reflect === \"object\" && typeof Reflect.metadata === \"function\") return Reflect.metadata(k, v);\n\t};\n\tvar core_1 = __webpack_require__(3);\n\tvar router_1 = __webpack_require__(29);\n\tvar forms_1 = __webpack_require__(389);\n\tvar shared_module_1 = __webpack_require__(387);\n\tvar devices_module_1 = __webpack_require__(434);\n\tvar scenarios_routing_1 = __webpack_require__(563);\n\tvar scenario_list_resolve_service_1 = __webpack_require__(583);\n\tvar scenario_status_service_1 = __webpack_require__(580);\n\tvar scenario_service_1 = __webpack_require__(565);\n\tvar scenarios_declarations_1 = __webpack_require__(584);\n\tvar ScenariosModule = (function () {\n\t    function ScenariosModule() {\n\t    }\n\t    ScenariosModule = __decorate([\n\t        core_1.NgModule({\n\t            id: module.id,\n\t            imports: [\n\t                router_1.RouterModule,\n\t                forms_1.FormsModule,\n\t                shared_module_1.SharedModule,\n\t                devices_module_1.DevicesModule,\n\t                scenarios_routing_1.routing\n\t            ],\n\t            declarations: scenarios_declarations_1.default.slice(),\n\t            exports: scenarios_declarations_1.default.slice(),\n\t            providers: [\n\t                scenario_list_resolve_service_1.ScenarioListResolveService,\n\t                scenario_status_service_1.ScenarioStatusService,\n\t                scenario_service_1.ScenarioService\n\t            ]\n\t        }), \n\t        __metadata('design:paramtypes', [])\n\t    ], ScenariosModule);\n\t    return ScenariosModule;\n\t}());\n\texports.ScenariosModule = ScenariosModule;\n\n\n/***/ },\n\n/***/ 563:\n/***/ function(module, exports, __webpack_require__) {\n\n\t\"use strict\";\n\tvar router_1 = __webpack_require__(29);\n\tvar create_scenario_editor_component_1 = __webpack_require__(564);\n\tvar edit_scenario_editor_component_1 = __webpack_require__(572);\n\tvar create_scenario_wizard_component_1 = __webpack_require__(573);\n\tvar edit_scenario_wizard_component_1 = __webpack_require__(577);\n\tvar scenario_list_component_1 = __webpack_require__(579);\n\tvar scenario_list_resolve_service_1 = __webpack_require__(583);\n\texports.routes = [\n\t    {\n\t        path: '',\n\t        children: [\n\t            {\n\t                path: '', component: scenario_list_component_1.ScenarioListComponent,\n\t                resolve: { scenarioList: scenario_list_resolve_service_1.ScenarioListResolveService }\n\t            },\n\t            {\n\t                path: 'editor-create',\n\t                component: create_scenario_editor_component_1.CreateScenarioEditorComponent\n\t            },\n\t            {\n\t                path: 'wizard-create',\n\t                component: create_scenario_wizard_component_1.CreateScenarioWizardComponent\n\t            },\n\t            {\n\t                path: 'editor/:id',\n\t                component: edit_scenario_editor_component_1.EditScenarioEditorComponent\n\t            },\n\t            {\n\t                path: 'wizard/:id',\n\t                component: edit_scenario_wizard_component_1.EditScenarioWizardComponent\n\t            },\n\t        ]\n\t    }\n\t];\n\texports.routing = router_1.RouterModule.forChild(exports.routes);\n\n\n/***/ },\n\n/***/ 564:\n/***/ function(module, exports, __webpack_require__) {\n\n\t\"use strict\";\n\tvar __extends = (this && this.__extends) || function (d, b) {\n\t    for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];\n\t    function __() { this.constructor = d; }\n\t    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());\n\t};\n\tvar __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {\n\t    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;\n\t    if (typeof Reflect === \"object\" && typeof Reflect.decorate === \"function\") r = Reflect.decorate(decorators, target, key, desc);\n\t    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;\n\t    return c > 3 && r && Object.defineProperty(target, key, r), r;\n\t};\n\tvar __metadata = (this && this.__metadata) || function (k, v) {\n\t    if (typeof Reflect === \"object\" && typeof Reflect.metadata === \"function\") return Reflect.metadata(k, v);\n\t};\n\tvar core_1 = __webpack_require__(3);\n\tvar router_1 = __webpack_require__(29);\n\tvar scenario_service_1 = __webpack_require__(565);\n\tvar scenario_details_component_1 = __webpack_require__(566);\n\tvar CreateScenarioEditorComponent = (function (_super) {\n\t    __extends(CreateScenarioEditorComponent, _super);\n\t    function CreateScenarioEditorComponent(_scenarioService, _route, _router) {\n\t        _super.call(this, _scenarioService, _route, _router);\n\t    }\n\t    CreateScenarioEditorComponent.prototype.save = function (scenario) {\n\t        var _this = this;\n\t        this._scenarioService.create(scenario)\n\t            .subscribe(function () { return _this.back(); });\n\t    };\n\t    CreateScenarioEditorComponent.prototype.onScenarioBodyUpdate = function (_a) {\n\t        var scenarioBody = _a.scenarioBody;\n\t        this.scenario['body'] = scenarioBody;\n\t    };\n\t    CreateScenarioEditorComponent = __decorate([\n\t        core_1.Component({\n\t            template: __webpack_require__(570),\n\t            styles: [__webpack_require__(571)]\n\t        }), \n\t        __metadata('design:paramtypes', [(typeof (_a = typeof scenario_service_1.ScenarioService !== 'undefined' && scenario_service_1.ScenarioService) === 'function' && _a) || Object, (typeof (_b = typeof router_1.ActivatedRoute !== 'undefined' && router_1.ActivatedRoute) === 'function' && _b) || Object, (typeof (_c = typeof router_1.Router !== 'undefined' && router_1.Router) === 'function' && _c) || Object])\n\t    ], CreateScenarioEditorComponent);\n\t    return CreateScenarioEditorComponent;\n\t    var _a, _b, _c;\n\t}(scenario_details_component_1.ScenarioDetailsComponent));\n\texports.CreateScenarioEditorComponent = CreateScenarioEditorComponent;\n\n\n/***/ },\n\n/***/ 565:\n/***/ function(module, exports, __webpack_require__) {\n\n\t\"use strict\";\n\tvar __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {\n\t    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;\n\t    if (typeof Reflect === \"object\" && typeof Reflect.decorate === \"function\") r = Reflect.decorate(decorators, target, key, desc);\n\t    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;\n\t    return c > 3 && r && Object.defineProperty(target, key, r), r;\n\t};\n\tvar __metadata = (this && this.__metadata) || function (k, v) {\n\t    if (typeof Reflect === \"object\" && typeof Reflect.metadata === \"function\") return Reflect.metadata(k, v);\n\t};\n\tvar core_1 = __webpack_require__(3);\n\tvar sh_http_service_1 = __webpack_require__(67);\n\t// TODO: let's use 'streams' approach. All promises functions should be\n\t// removed in future after refactoring\n\tvar ScenarioService = (function () {\n\t    function ScenarioService(http) {\n\t        this.http = http;\n\t        this.http = http;\n\t    }\n\t    ScenarioService.prototype.get = function (id) {\n\t        if (id === void 0) { id = ''; }\n\t        return this.http.get(\"/scenarios/\" + id);\n\t    };\n\t    ScenarioService.prototype.update = function (scenario, isWizard) {\n\t        return this.http.put(\"/scenarios/\" + scenario.id, getScenario(scenario, isWizard));\n\t    };\n\t    ScenarioService.prototype.create = function (scenario, isWizard) {\n\t        return this.http.post('/scenarios', getScenario(scenario, isWizard));\n\t    };\n\t    ScenarioService.prototype.delete = function (scenario) {\n\t        return this.http.delete(\"/scenarios/\" + scenario.id);\n\t    };\n\t    ScenarioService = __decorate([\n\t        core_1.Injectable(), \n\t        __metadata('design:paramtypes', [(typeof (_a = typeof sh_http_service_1.ShHttpService !== 'undefined' && sh_http_service_1.ShHttpService) === 'function' && _a) || Object])\n\t    ], ScenarioService);\n\t    return ScenarioService;\n\t    var _a;\n\t}());\n\texports.ScenarioService = ScenarioService;\n\tfunction getScenario(scenario, isWizard) {\n\t    return isWizard ? mapScenario(scenario) : cleanScenario(scenario);\n\t}\n\tfunction cleanScenario(scenario) {\n\t    var result = Object.assign({}, scenario);\n\t    delete result.sourceType;\n\t    delete result.wizard;\n\t    return result;\n\t}\n\tfunction mapScenario(scenario) {\n\t    var logicalOperator = scenario.wizard.logicalOperator;\n\t    var conditions = getConditions(scenario.wizard.conditions);\n\t    var actions = getActions(scenario.wizard.actions);\n\t    return Object.assign({}, scenario, {\n\t        isConvertable: true,\n\t        body: '',\n\t        wizard: {\n\t            logicalOperator: logicalOperator,\n\t            conditions: conditions,\n\t            actions: actions\n\t        }\n\t    });\n\t    function getConditions(_conditions) {\n\t        return _conditions.map(function (condition) { return ({\n\t            device: condition.selectedDevice,\n\t            condition: condition.selectedCondition,\n\t            value: condition.value\n\t        }); });\n\t    }\n\t    function getActions(_actions) {\n\t        return _actions.map(function (item) { return ({\n\t            device: item.selectedDevice,\n\t            value: item.value\n\t        }); });\n\t    }\n\t}\n\n\n/***/ },\n\n/***/ 566:\n/***/ function(module, exports, __webpack_require__) {\n\n\t\"use strict\";\n\tvar __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {\n\t    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;\n\t    if (typeof Reflect === \"object\" && typeof Reflect.decorate === \"function\") r = Reflect.decorate(decorators, target, key, desc);\n\t    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;\n\t    return c > 3 && r && Object.defineProperty(target, key, r), r;\n\t};\n\tvar __metadata = (this && this.__metadata) || function (k, v) {\n\t    if (typeof Reflect === \"object\" && typeof Reflect.metadata === \"function\") return Reflect.metadata(k, v);\n\t};\n\tvar core_1 = __webpack_require__(3);\n\tvar router_1 = __webpack_require__(29);\n\tvar scenario_service_1 = __webpack_require__(565);\n\tvar scenario_1 = __webpack_require__(567);\n\tvar ScenarioDetailsComponent = (function () {\n\t    // TODO remove route:ActivatedRoute to null\n\t    function ScenarioDetailsComponent(_scenarioService, _route, _router) {\n\t        this._scenarioService = _scenarioService;\n\t        this._route = _route;\n\t        this._router = _router;\n\t        this.scenario = new scenario_1.Scenario;\n\t    }\n\t    ScenarioDetailsComponent.prototype.onScenarioBodyUpdate = function (_a) {\n\t        var scenarioBody = _a.scenarioBody;\n\t        this.scenario['body'] = scenarioBody;\n\t    };\n\t    ScenarioDetailsComponent.prototype.back = function () {\n\t        this._router.navigate(['/scenarios']);\n\t    };\n\t    ScenarioDetailsComponent = __decorate([\n\t        core_1.Component({\n\t            selector: 'sh-scenario-list',\n\t            template: __webpack_require__(568),\n\t            styles: [__webpack_require__(569)]\n\t        }), \n\t        __metadata('design:paramtypes', [(typeof (_a = typeof scenario_service_1.ScenarioService !== 'undefined' && scenario_service_1.ScenarioService) === 'function' && _a) || Object, (typeof (_b = typeof router_1.ActivatedRoute !== 'undefined' && router_1.ActivatedRoute) === 'function' && _b) || Object, (typeof (_c = typeof router_1.Router !== 'undefined' && router_1.Router) === 'function' && _c) || Object])\n\t    ], ScenarioDetailsComponent);\n\t    return ScenarioDetailsComponent;\n\t    var _a, _b, _c;\n\t}());\n\texports.ScenarioDetailsComponent = ScenarioDetailsComponent;\n\n\n/***/ },\n\n/***/ 567:\n/***/ function(module, exports) {\n\n\t\"use strict\";\n\tvar DEFAULT_SCENARIO_STATE = {\n\t    active: false,\n\t    isConvertable: false\n\t};\n\tvar Scenario = (function () {\n\t    function Scenario(data) {\n\t        if (data === void 0) { data = {}; }\n\t        Object.assign(this, DEFAULT_SCENARIO_STATE, {\n\t            wizard: {} // create empty wizard object if needed\n\t        }, data);\n\t    }\n\t    return Scenario;\n\t}());\n\texports.Scenario = Scenario;\n\n\n/***/ },\n\n/***/ 568:\n/***/ function(module, exports) {\n\n\tmodule.exports = \"<div class=\\\"page-header\\\">\\n    <div class=\\\"row\\\">\\n        <div class=\\\"col s3\\\">\\n            <a class=\\\"back-link valign-wrapper\\\" (click)=\\\"back()\\\">\\n                <i class=\\\"material-icons md-18\\\">navigate_before</i>\\n                Back to list\\n            </a>\\n        </div>\\n        <div class=\\\"col s12\\\" *ngIf=\\\"isWizardAvailable()\\\">\\n            <a [routerLink]=\\\"['../wizard-create']\\\" class=\\\"nav-link right\\\">\\n                <i class=\\\"material-icons\\\">edit</i>\\n                Go to Wizard\\n            </a>\\n        </div>\\n    </div>\\n</div>\\n\\n<form class=\\\"scenario-details\\\"\\n       (ngSubmit)=\\\"save(scenario)\\\"\\n       #scenarioDetailsForm=\\\"ngForm\\\">\\n    <label>\\n        Scenario name:\\n        <input [(ngModel)]=\\\"scenario.name\\\"\\n               name=\\\"name\\\"\\n               #name=\\\"ngModel\\\"\\n               class=\\\"black-text\\\"\\n               type=\\\"text\\\"/>\\n    </label>\\n\\n    <p class=\\\"sensor-detail__status\\\">\\n        <input [(ngModel)]=\\\"scenario.active\\\"\\n               name=\\\"active\\\"\\n               #active=\\\"ngModel\\\"\\n               class=\\\"filled-in sensor-detail__status-value\\\"\\n               type=\\\"checkbox\\\" id=\\\"scenario-details__status\\\"/>\\n        <label for=\\\"scenario-details__status\\\">Active</label>\\n    </p>\\n\\n    <label>\\n        Scenario description:\\n        <input [(ngModel)]=\\\"scenario.description\\\"\\n               name=\\\"description\\\"\\n               #description=\\\"ngModel\\\"\\n               class=\\\"black-text\\\"\\n               type=\\\"text\\\"/>\\n    </label>\\n\\n    <div class=\\\"scenario-details_editor-wrapper\\\">\\n        <sh-scenario-editor\\n            [scenario]=\\\"scenario?.body\\\"\\n            (updateScenario)=\\\"onScenarioBodyUpdate($event)\\\">\\n        </sh-scenario-editor>\\n    </div>\\n\\n    <button class=\\\"waves-effect waves-light btn blue-grey darken-1\\\"\\n            type=\\\"submit\\\"\\n            [disabled]=\\\"!scenarioDetailsForm.valid\\\">\\n        SAVE SCENARIO\\n    </button>\\n    <button (click)=\\\"delete(scenario)\\\"\\n            type=\\\"button\\\"\\n            class=\\\"waves-effect waves-light btn blue-grey darken-1\\\">\\n        Remove SCENARIO\\n    </button>\\n\\n</form>\\n\"\n\n/***/ },\n\n/***/ 569:\n/***/ function(module, exports) {\n\n\tmodule.exports = \".scenario-details_editor-wrapper{padding:20px 0 30px}.scenario-details a .label{display:block}\\n\"\n\n/***/ },\n\n/***/ 570:\n/***/ function(module, exports) {\n\n\tmodule.exports = \"<div class=\\\"page-header\\\">\\n    <div class=\\\"row\\\">\\n        <div class=\\\"col s3\\\">\\n            <a class=\\\"back-link\\\" (click)=\\\"back()\\\">\\n                <i class=\\\"material-icons md-18\\\">navigate_before</i>\\n                Back to list\\n            </a>\\n        </div>\\n    </div>\\n    <div class=\\\"row\\\">\\n        <div class=\\\"col s7\\\">\\n            <h1>New scenario</h1>\\n        </div>\\n        <div class=\\\"col s5\\\">\\n            <a [routerLink]=\\\"['../wizard-create']\\\" class=\\\"nav-link right\\\">\\n                <i class=\\\"material-icons\\\">edit</i>\\n                Go to Wizard\\n            </a>\\n        </div>\\n    </div>\\n</div>\\n\\n<form class=\\\"scenario-details\\\" (ngSubmit)=\\\"save(scenario)\\\">\\n    <label>\\n        Scenario name: <b class=\\\"red-text\\\">*</b>\\n        <input [(ngModel)]=\\\"scenario.name\\\"\\n               name=\\\"name\\\"\\n               #name=\\\"ngModel\\\"\\n               class=\\\"black-text\\\"\\n               type=\\\"text\\\"\\n               required\\n               />\\n    </label>\\n    <div [hidden]=\\\"!name.touched || name.valid\\\" class=\\\"red-text text-darken-4\\\">\\n        Name should be filled\\n    </div>\\n\\n    <p class=\\\"sensor-detail__status\\\">\\n        <input [(ngModel)]=\\\"scenario.active\\\"\\n               name=\\\"active\\\"\\n               #active=\\\"ngModel\\\"\\n               class=\\\"filled-in sensor-detail__status-value\\\"\\n               type=\\\"checkbox\\\" id=\\\"scenario-details__status\\\"/>\\n        <label for=\\\"scenario-details__status\\\">active </label>\\n    </p>\\n\\n    <label>\\n        Scenario description:\\n        <input [(ngModel)]=\\\"scenario.description\\\"\\n               name=\\\"description\\\"\\n               #description=\\\"ngModel\\\"\\n               class=\\\"black-text\\\"\\n               type=\\\"text\\\"/>\\n    </label>\\n\\n    <div class=\\\"scenario-details_editor-wrapper\\\">\\n        <sh-scenario-editor\\n            [scenario]=\\\"scenario?.body\\\"\\n            (updateScenario)=\\\"onScenarioBodyUpdate($event)\\\">\\n        </sh-scenario-editor>\\n    </div>\\n\\n    <button class=\\\"waves-effect waves-light btn blue-grey darken-1\\\" type=\\\"submit\\\">SAVE SCENARIO</button>\\n</form>\\n\"\n\n/***/ },\n\n/***/ 571:\n/***/ function(module, exports) {\n\n\tmodule.exports = \".scenario_item__body{max-height:6em;overflow:hidden}.scenario-details_editor-wrapper{padding:20px 0 30px}.scenario-details a .label{display:block}\\n\"\n\n/***/ },\n\n/***/ 572:\n/***/ function(module, exports, __webpack_require__) {\n\n\t\"use strict\";\n\tvar __extends = (this && this.__extends) || function (d, b) {\n\t    for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];\n\t    function __() { this.constructor = d; }\n\t    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());\n\t};\n\tvar __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {\n\t    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;\n\t    if (typeof Reflect === \"object\" && typeof Reflect.decorate === \"function\") r = Reflect.decorate(decorators, target, key, desc);\n\t    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;\n\t    return c > 3 && r && Object.defineProperty(target, key, r), r;\n\t};\n\tvar __metadata = (this && this.__metadata) || function (k, v) {\n\t    if (typeof Reflect === \"object\" && typeof Reflect.metadata === \"function\") return Reflect.metadata(k, v);\n\t};\n\tvar core_1 = __webpack_require__(3);\n\tvar router_1 = __webpack_require__(29);\n\tvar scenario_details_component_1 = __webpack_require__(566);\n\tvar scenario_service_1 = __webpack_require__(565);\n\tvar dialog_service_1 = __webpack_require__(398);\n\tvar EditScenarioEditorComponent = (function (_super) {\n\t    __extends(EditScenarioEditorComponent, _super);\n\t    function EditScenarioEditorComponent(scenarioListService, router, route, dialogService, viewContainerRef) {\n\t        _super.call(this, scenarioListService, route, router);\n\t        this.scenarioListService = scenarioListService;\n\t        this.router = router;\n\t        this.route = route;\n\t        this.dialogService = dialogService;\n\t        this.viewContainerRef = viewContainerRef;\n\t    }\n\t    EditScenarioEditorComponent.prototype.ngOnInit = function () {\n\t        var _this = this;\n\t        this._scenarioService.get(this._route.snapshot.params['id'])\n\t            .subscribe(function (scenario) {\n\t            _this.scenario = scenario;\n\t        });\n\t    };\n\t    EditScenarioEditorComponent.prototype.save = function (scenario) {\n\t        var _this = this;\n\t        this._scenarioService.update(scenario)\n\t            .subscribe(function () {\n\t            _this.back();\n\t        });\n\t    };\n\t    EditScenarioEditorComponent.prototype.delete = function (scenario) {\n\t        var _this = this;\n\t        var confirmOptions = {\n\t            title: '',\n\t            message: 'Are you sure you want to delete this scenario?'\n\t        };\n\t        this.dialogService.confirm(this.viewContainerRef, confirmOptions)\n\t            .filter(function (isConfirmed) { return isConfirmed; })\n\t            .subscribe(function () {\n\t            _this._scenarioService\n\t                .delete(scenario)\n\t                .subscribe(function () {\n\t                _this.back();\n\t            });\n\t        });\n\t    };\n\t    EditScenarioEditorComponent.prototype.isWizardAvailable = function () {\n\t        return false;\n\t    };\n\t    EditScenarioEditorComponent = __decorate([\n\t        core_1.Component({\n\t            selector: 'sh-scenario-list',\n\t            template: __webpack_require__(568),\n\t            styles: [__webpack_require__(569)]\n\t        }), \n\t        __metadata('design:paramtypes', [(typeof (_a = typeof scenario_service_1.ScenarioService !== 'undefined' && scenario_service_1.ScenarioService) === 'function' && _a) || Object, (typeof (_b = typeof router_1.Router !== 'undefined' && router_1.Router) === 'function' && _b) || Object, (typeof (_c = typeof router_1.ActivatedRoute !== 'undefined' && router_1.ActivatedRoute) === 'function' && _c) || Object, (typeof (_d = typeof dialog_service_1.DialogService !== 'undefined' && dialog_service_1.DialogService) === 'function' && _d) || Object, (typeof (_e = typeof core_1.ViewContainerRef !== 'undefined' && core_1.ViewContainerRef) === 'function' && _e) || Object])\n\t    ], EditScenarioEditorComponent);\n\t    return EditScenarioEditorComponent;\n\t    var _a, _b, _c, _d, _e;\n\t}(scenario_details_component_1.ScenarioDetailsComponent));\n\texports.EditScenarioEditorComponent = EditScenarioEditorComponent;\n\n\n/***/ },\n\n/***/ 573:\n/***/ function(module, exports, __webpack_require__) {\n\n\t\"use strict\";\n\tvar __extends = (this && this.__extends) || function (d, b) {\n\t    for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];\n\t    function __() { this.constructor = d; }\n\t    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());\n\t};\n\tvar __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {\n\t    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;\n\t    if (typeof Reflect === \"object\" && typeof Reflect.decorate === \"function\") r = Reflect.decorate(decorators, target, key, desc);\n\t    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;\n\t    return c > 3 && r && Object.defineProperty(target, key, r), r;\n\t};\n\tvar __metadata = (this && this.__metadata) || function (k, v) {\n\t    if (typeof Reflect === \"object\" && typeof Reflect.metadata === \"function\") return Reflect.metadata(k, v);\n\t};\n\tvar core_1 = __webpack_require__(3);\n\tvar router_1 = __webpack_require__(29);\n\tvar devices_service_1 = __webpack_require__(420);\n\tvar scenario_details_component_1 = __webpack_require__(566);\n\tvar scenario_service_1 = __webpack_require__(565);\n\tvar action_1 = __webpack_require__(574);\n\tvar condition_1 = __webpack_require__(575);\n\tvar scenario_1 = __webpack_require__(567);\n\tvar CreateScenarioWizardComponent = (function (_super) {\n\t    __extends(CreateScenarioWizardComponent, _super);\n\t    function CreateScenarioWizardComponent(_scenarioService, _route, _router, devicesService) {\n\t        _super.call(this, _scenarioService, _route, _router);\n\t        this._scenarioService = _scenarioService;\n\t        this._route = _route;\n\t        this._router = _router;\n\t        this.devicesService = devicesService;\n\t    }\n\t    CreateScenarioWizardComponent.prototype.ngOnInit = function () {\n\t        var _this = this;\n\t        this.devicesService\n\t            .getSensors()\n\t            .subscribe(function (devices) {\n\t            _this.devices = devices;\n\t            var newScenario = {\n\t                wizard: {\n\t                    conditions: [new condition_1.Condition(devices)],\n\t                    actions: [new action_1.Action(devices)]\n\t                }\n\t            };\n\t            _this.scenario = new scenario_1.Scenario(newScenario);\n\t        });\n\t    };\n\t    CreateScenarioWizardComponent.prototype.onAddCriteria = function () {\n\t        this.scenario['wizard']['conditions'].push(new condition_1.Condition(this.devices));\n\t    };\n\t    CreateScenarioWizardComponent.prototype.onRemoveCriteria = function (index) {\n\t        this.scenario['wizard']['conditions'].splice(index, 1);\n\t    };\n\t    CreateScenarioWizardComponent.prototype.onAddAction = function () {\n\t        this.scenario['wizard']['actions'].push(new action_1.Action(this.devices));\n\t    };\n\t    CreateScenarioWizardComponent.prototype.onRemoveAction = function (index) {\n\t        this.scenario['wizard']['actions'].splice(index, 1);\n\t    };\n\t    CreateScenarioWizardComponent.prototype.save = function (scenario) {\n\t        var _this = this;\n\t        this._scenarioService.create(scenario, true)\n\t            .subscribe(function () { return _this.back(); });\n\t    };\n\t    CreateScenarioWizardComponent = __decorate([\n\t        core_1.Component({\n\t            template: __webpack_require__(576),\n\t        }), \n\t        __metadata('design:paramtypes', [(typeof (_a = typeof scenario_service_1.ScenarioService !== 'undefined' && scenario_service_1.ScenarioService) === 'function' && _a) || Object, (typeof (_b = typeof router_1.ActivatedRoute !== 'undefined' && router_1.ActivatedRoute) === 'function' && _b) || Object, (typeof (_c = typeof router_1.Router !== 'undefined' && router_1.Router) === 'function' && _c) || Object, (typeof (_d = typeof devices_service_1.DevicesService !== 'undefined' && devices_service_1.DevicesService) === 'function' && _d) || Object])\n\t    ], CreateScenarioWizardComponent);\n\t    return CreateScenarioWizardComponent;\n\t    var _a, _b, _c, _d;\n\t}(scenario_details_component_1.ScenarioDetailsComponent));\n\texports.CreateScenarioWizardComponent = CreateScenarioWizardComponent;\n\n\n/***/ },\n\n/***/ 574:\n/***/ function(module, exports) {\n\n\t\"use strict\";\n\tvar Action = (function () {\n\t    function Action(devices, initOptions) {\n\t        if (initOptions === void 0) { initOptions = { value: '', device: null }; }\n\t        this.devices = devices;\n\t        this.selectedDevice = initOptions.device;\n\t        this.values = [\n\t            { id: 'ON', name: 'Turn ON' }, { id: 'OFF', name: 'Turn OFF' }\n\t        ];\n\t        this.value = initOptions.value;\n\t    }\n\t    return Action;\n\t}());\n\texports.Action = Action;\n\n\n/***/ },\n\n/***/ 575:\n/***/ function(module, exports) {\n\n\t\"use strict\";\n\tvar Condition = (function () {\n\t    function Condition(devices, initOptions) {\n\t        if (initOptions === void 0) { initOptions = { device: null, value: '', condition: null }; }\n\t        this.devices = devices;\n\t        this.selectedDevice = initOptions.device;\n\t        this.conditions = [\n\t            { id: 'GREATER_THAN', name: 'GREATER THAN', sign: '>' },\n\t            { id: 'GREATER_THAN_OR_EQUAL_TO', name: 'GREATER OR EQUAL', sign: '>=' },\n\t            { id: 'LESS_THAN', name: 'LESS THAN', sign: '<' },\n\t            { id: 'LESS_THAN_OR_EQUAL_TO', name: 'LESS THAN OR EQUAL TO', sign: '<=' },\n\t            { id: 'EQUAL_TO', name: 'EQUAL TO', sign: '==' },\n\t            { id: 'NOT_EQUAL', name: 'NOT EQUAL', sign: '!=' }\n\t        ];\n\t        this.selectedCondition = initOptions.condition;\n\t        this.value = initOptions.value;\n\t    }\n\t    return Condition;\n\t}());\n\texports.Condition = Condition;\n\n\n/***/ },\n\n/***/ 576:\n/***/ function(module, exports) {\n\n\tmodule.exports = \"<div class=\\\"page-header\\\">\\n    <div class=\\\"row\\\">\\n        <div class=\\\"col s3\\\">\\n            <a class=\\\"back-link\\\" (click)=\\\"back()\\\">\\n                <i class=\\\"material-icons md-18\\\">navigate_before</i>\\n                Back to list\\n            </a>\\n        </div>\\n    </div>\\n    <div class=\\\"row\\\">\\n        <div class=\\\"col s7\\\">\\n            <h1>New scenario</h1>\\n        </div>\\n        <div class=\\\"col s5\\\">\\n            <a [routerLink]=\\\"['../editor-create']\\\" class=\\\"nav-link right\\\">\\n                <i class=\\\"material-icons\\\">edit</i>\\n                Go to Editor\\n            </a>\\n        </div>\\n    </div>\\n</div>\\n\\n<form class=\\\"scenario-details\\\"\\n        (ngSubmit)=\\\"save(scenario)\\\"\\n        #createScenarioWizardForm=\\\"ngForm\\\">\\n    <sh-scenario-wizard\\n        *ngIf=\\\"scenario && scenario.wizard\\\"\\n        [scenario]=\\\"scenario\\\"\\n        (onAddCriteria)=\\\"onAddCriteria()\\\"\\n        (onRemoveCriteria)=\\\"onRemoveCriteria($event)\\\"\\n        (onAddAction)=\\\"onAddAction()\\\"\\n        (onRemoveAction)=\\\"onRemoveAction($event)\\\">\\n    </sh-scenario-wizard>\\n\\n    <button class=\\\"waves-effect waves-light btn blue-grey darken-1\\\"\\n            type=\\\"submit\\\"\\n            [disabled]=\\\"!createScenarioWizardForm.valid\\\">\\n        SAVE SCENARIO\\n    </button>\\n</form>\\n\"\n\n/***/ },\n\n/***/ 577:\n/***/ function(module, exports, __webpack_require__) {\n\n\t\"use strict\";\n\tvar __extends = (this && this.__extends) || function (d, b) {\n\t    for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];\n\t    function __() { this.constructor = d; }\n\t    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());\n\t};\n\tvar __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {\n\t    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;\n\t    if (typeof Reflect === \"object\" && typeof Reflect.decorate === \"function\") r = Reflect.decorate(decorators, target, key, desc);\n\t    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;\n\t    return c > 3 && r && Object.defineProperty(target, key, r), r;\n\t};\n\tvar __metadata = (this && this.__metadata) || function (k, v) {\n\t    if (typeof Reflect === \"object\" && typeof Reflect.metadata === \"function\") return Reflect.metadata(k, v);\n\t};\n\tvar core_1 = __webpack_require__(3);\n\tvar router_1 = __webpack_require__(29);\n\tvar devices_service_1 = __webpack_require__(420);\n\tvar scenario_service_1 = __webpack_require__(565);\n\tvar create_scenario_wizard_component_1 = __webpack_require__(573);\n\tvar condition_1 = __webpack_require__(575);\n\tvar action_1 = __webpack_require__(574);\n\tvar scenario_1 = __webpack_require__(567);\n\tvar Rx_1 = __webpack_require__(81);\n\tvar dialog_service_1 = __webpack_require__(398);\n\tvar EditScenarioWizardComponent = (function (_super) {\n\t    __extends(EditScenarioWizardComponent, _super);\n\t    function EditScenarioWizardComponent(_scenarioService, _route, _router, dialogService, viewContainerRef, devicesService) {\n\t        _super.call(this, _scenarioService, _route, _router, devicesService);\n\t        this._scenarioService = _scenarioService;\n\t        this._route = _route;\n\t        this._router = _router;\n\t        this.dialogService = dialogService;\n\t        this.viewContainerRef = viewContainerRef;\n\t        this.devicesService = devicesService;\n\t    }\n\t    EditScenarioWizardComponent.prototype.ngOnInit = function () {\n\t        var _this = this;\n\t        var deviceListStream = this.devicesService.getSensors();\n\t        var scenarioStream = this._scenarioService.get(this._route.snapshot.params['id']);\n\t        var source = Rx_1.Observable.forkJoin(deviceListStream, scenarioStream);\n\t        source.subscribe(function (result) {\n\t            var devices = result[0];\n\t            var scenario = result[1];\n\t            _this.devices = devices;\n\t            scenario.wizard = {\n\t                logicalOperator: scenario.wizard && scenario.wizard.logicalOperator,\n\t                conditions: mapConditions(_this.devices, scenario.wizard.conditions),\n\t                actions: mapActions(_this.devices, scenario.wizard.actions)\n\t            };\n\t            _this.scenario = new scenario_1.Scenario(scenario);\n\t        });\n\t        function mapConditions(devices, conditions) {\n\t            return conditions.map(function (condition) { return new condition_1.Condition(devices, condition); });\n\t        }\n\t        function mapActions(devices, actions) {\n\t            return actions.map(function (action) { return new action_1.Action(devices, action); });\n\t        }\n\t    };\n\t    EditScenarioWizardComponent.prototype.save = function (scenario) {\n\t        var _this = this;\n\t        this._scenarioService.update(scenario, true)\n\t            .subscribe(function () {\n\t            _this.back();\n\t        });\n\t    };\n\t    EditScenarioWizardComponent.prototype.delete = function (scenario) {\n\t        var _this = this;\n\t        var confirmOptions = {\n\t            title: '',\n\t            message: 'Are you sure you want to delete this scenario?'\n\t        };\n\t        this.dialogService.confirm(this.viewContainerRef, confirmOptions)\n\t            .filter(function (isConfirmed) { return isConfirmed; })\n\t            .subscribe(function () {\n\t            _this._scenarioService\n\t                .delete(scenario)\n\t                .subscribe(function (data) {\n\t                _this.back();\n\t            });\n\t        });\n\t    };\n\t    EditScenarioWizardComponent = __decorate([\n\t        core_1.Component({\n\t            template: __webpack_require__(578)\n\t        }), \n\t        __metadata('design:paramtypes', [(typeof (_a = typeof scenario_service_1.ScenarioService !== 'undefined' && scenario_service_1.ScenarioService) === 'function' && _a) || Object, (typeof (_b = typeof router_1.ActivatedRoute !== 'undefined' && router_1.ActivatedRoute) === 'function' && _b) || Object, (typeof (_c = typeof router_1.Router !== 'undefined' && router_1.Router) === 'function' && _c) || Object, (typeof (_d = typeof dialog_service_1.DialogService !== 'undefined' && dialog_service_1.DialogService) === 'function' && _d) || Object, (typeof (_e = typeof core_1.ViewContainerRef !== 'undefined' && core_1.ViewContainerRef) === 'function' && _e) || Object, (typeof (_f = typeof devices_service_1.DevicesService !== 'undefined' && devices_service_1.DevicesService) === 'function' && _f) || Object])\n\t    ], EditScenarioWizardComponent);\n\t    return EditScenarioWizardComponent;\n\t    var _a, _b, _c, _d, _e, _f;\n\t}(create_scenario_wizard_component_1.CreateScenarioWizardComponent));\n\texports.EditScenarioWizardComponent = EditScenarioWizardComponent;\n\n\n/***/ },\n\n/***/ 578:\n/***/ function(module, exports) {\n\n\tmodule.exports = \"<div class=\\\"page-header\\\">\\n    <div class=\\\"row\\\">\\n        <div class=\\\"col s3\\\">\\n            <a class=\\\"back-link\\\" (click)=\\\"back()\\\">\\n                <i class=\\\"material-icons md-18\\\">navigate_before</i>\\n                Back to list\\n            </a>\\n        </div>\\n    </div>\\n</div>\\n\\n<form class=\\\"scenario-details\\\"\\n        (ngSubmit)=\\\"save(scenario)\\\"\\n        #editScenarioWizardForm=\\\"ngForm\\\">\\n    <sh-scenario-wizard\\n        *ngIf=\\\"scenario && scenario.wizard\\\"\\n        [scenario]=\\\"scenario\\\"\\n        (onAddCriteria)=\\\"onAddCriteria()\\\"\\n        (onRemoveCriteria)=\\\"onRemoveCriteria()\\\"\\n        (onAddAction)=\\\"onAddAction()\\\"\\n        (onRemoveAction)=\\\"onRemoveAction()\\\">\\n    </sh-scenario-wizard>\\n\\n    <button class=\\\"waves-effect waves-light btn blue-grey darken-1\\\"\\n            type=\\\"submit\\\"\\n            [disabled]=\\\"!editScenarioWizardForm.valid\\\">\\n        SAVE SCENARIO\\n    </button>\\n    <button (click)=\\\"delete(scenario)\\\"\\n            type=\\\"button\\\"\\n            class=\\\"waves-effect waves-light btn blue-grey darken-1\\\">\\n        Remove SCENARIO\\n    </button>\\n</form>\\n\"\n\n/***/ },\n\n/***/ 579:\n/***/ function(module, exports, __webpack_require__) {\n\n\t\"use strict\";\n\tvar __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {\n\t    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;\n\t    if (typeof Reflect === \"object\" && typeof Reflect.decorate === \"function\") r = Reflect.decorate(decorators, target, key, desc);\n\t    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;\n\t    return c > 3 && r && Object.defineProperty(target, key, r), r;\n\t};\n\tvar __metadata = (this && this.__metadata) || function (k, v) {\n\t    if (typeof Reflect === \"object\" && typeof Reflect.metadata === \"function\") return Reflect.metadata(k, v);\n\t};\n\tvar core_1 = __webpack_require__(3);\n\tvar router_1 = __webpack_require__(29);\n\tvar scenario_service_1 = __webpack_require__(565);\n\tvar scenario_status_service_1 = __webpack_require__(580);\n\tvar dialog_service_1 = __webpack_require__(398);\n\tvar headersForDisplay = [\n\t    { topic: 'name', name: 'Name', sortable: true },\n\t    { topic: 'status', name: 'Status', sortable: false }\n\t];\n\texports.SCENARIO_ACTIVE_STATE = 'active';\n\texports.SCENARIO_PAUSED_STATE = 'paused';\n\tvar ScenarioListComponent = (function () {\n\t    function ScenarioListComponent(scenarioService, router, scenarioStatusService, route, dialogService, viewContainerRef) {\n\t        this.scenarioService = scenarioService;\n\t        this.router = router;\n\t        this.scenarioStatusService = scenarioStatusService;\n\t        this.route = route;\n\t        this.dialogService = dialogService;\n\t        this.viewContainerRef = viewContainerRef;\n\t        this.scenarioList = [];\n\t        this._headers = [];\n\t        this._headers = headersForDisplay;\n\t    }\n\t    ScenarioListComponent.prototype.ngOnInit = function () {\n\t        var _this = this;\n\t        this.route.data.subscribe(function (data) {\n\t            _this.scenarioList = data['scenarioList'].map(_this.convertScenarioStatus);\n\t        });\n\t        this.subscription = this.scenarioStatusService['stream'].subscribe(function (event) {\n\t            return _this.onScenarioStatusChange(event);\n\t        });\n\t    };\n\t    ScenarioListComponent.prototype.onScenarioStatusChange = function (event) {\n\t        var scenarioToChange = this.scenarioList.find(function (scenario) { return scenario.id === event.id; });\n\t        if (scenarioToChange) {\n\t            scenarioToChange.active = event.active;\n\t            this.convertScenarioStatus(scenarioToChange);\n\t        }\n\t    };\n\t    ScenarioListComponent.prototype.ngOnDestroy = function () {\n\t        this.subscription.unsubscribe();\n\t    };\n\t    Object.defineProperty(ScenarioListComponent.prototype, \"headers\", {\n\t        get: function () {\n\t            return this._headers;\n\t        },\n\t        enumerable: true,\n\t        configurable: true\n\t    });\n\t    ScenarioListComponent.prototype.removeScenario = function (item) {\n\t        var _this = this;\n\t        var confirmOptions = {\n\t            title: '',\n\t            message: 'Are you sure you want to delete this scenario?'\n\t        };\n\t        this.dialogService.confirm(this.viewContainerRef, confirmOptions)\n\t            .filter(function (isConfirmed) { return isConfirmed; })\n\t            .subscribe(function () {\n\t            _this.scenarioService\n\t                .delete(item)\n\t                .subscribe(function (data) {\n\t                _this.scenarioList = _this.scenarioList\n\t                    .filter(function (elem) { return elem.id !== data.id; });\n\t            });\n\t        });\n\t    };\n\t    ScenarioListComponent.prototype.toggleScenarioState = function (scenario) {\n\t        var _this = this;\n\t        var active = !scenario.active;\n\t        var scenarioForUpdate = Object.assign({}, scenario, { active: active });\n\t        this.scenarioService\n\t            .update(scenarioForUpdate)\n\t            .subscribe(function () {\n\t            Object.assign(scenario, {\n\t                active: !scenario.active\n\t            });\n\t            _this.convertScenarioStatus(scenario);\n\t        });\n\t    };\n\t    ScenarioListComponent.prototype.navigateToEditView = function (scenario) {\n\t        var route = scenario.isConvertable\n\t            ? 'scenarios/wizard'\n\t            : 'scenarios/editor';\n\t        this.router.navigate([route, scenario.id]);\n\t    };\n\t    ScenarioListComponent.prototype.convertScenarioStatus = function (scenario) {\n\t        return Object.assign(scenario, {\n\t            status: scenario.active ? exports.SCENARIO_ACTIVE_STATE : exports.SCENARIO_PAUSED_STATE\n\t        });\n\t    };\n\t    ScenarioListComponent = __decorate([\n\t        core_1.Component({\n\t            selector: 'sh-scenario-list',\n\t            template: __webpack_require__(581),\n\t            styles: [__webpack_require__(582)]\n\t        }), \n\t        __metadata('design:paramtypes', [(typeof (_a = typeof scenario_service_1.ScenarioService !== 'undefined' && scenario_service_1.ScenarioService) === 'function' && _a) || Object, (typeof (_b = typeof router_1.Router !== 'undefined' && router_1.Router) === 'function' && _b) || Object, (typeof (_c = typeof scenario_status_service_1.ScenarioStatusService !== 'undefined' && scenario_status_service_1.ScenarioStatusService) === 'function' && _c) || Object, (typeof (_d = typeof router_1.ActivatedRoute !== 'undefined' && router_1.ActivatedRoute) === 'function' && _d) || Object, (typeof (_e = typeof dialog_service_1.DialogService !== 'undefined' && dialog_service_1.DialogService) === 'function' && _e) || Object, (typeof (_f = typeof core_1.ViewContainerRef !== 'undefined' && core_1.ViewContainerRef) === 'function' && _f) || Object])\n\t    ], ScenarioListComponent);\n\t    return ScenarioListComponent;\n\t    var _a, _b, _c, _d, _e, _f;\n\t}());\n\texports.ScenarioListComponent = ScenarioListComponent;\n\n\n/***/ },\n\n/***/ 580:\n/***/ function(module, exports, __webpack_require__) {\n\n\t\"use strict\";\n\tvar __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {\n\t    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;\n\t    if (typeof Reflect === \"object\" && typeof Reflect.decorate === \"function\") r = Reflect.decorate(decorators, target, key, desc);\n\t    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;\n\t    return c > 3 && r && Object.defineProperty(target, key, r), r;\n\t};\n\tvar __metadata = (this && this.__metadata) || function (k, v) {\n\t    if (typeof Reflect === \"object\" && typeof Reflect.metadata === \"function\") return Reflect.metadata(k, v);\n\t};\n\tvar core_1 = __webpack_require__(3);\n\tvar io = __webpack_require__(446);\n\tvar Rx_1 = __webpack_require__(81);\n\texports.SCENARIO_STATUS_CHANGE_EVENT = 'scenario-status-change';\n\tvar ScenarioStatusService = (function () {\n\t    function ScenarioStatusService() {\n\t        this.io = io;\n\t        this.setup();\n\t    }\n\t    ScenarioStatusService.prototype.setup = function () {\n\t        var socket = this.io.connect(({\"backEndUrl\":\"\",\"backEndWebSocketUrl\":\"\"}).backEndWebSocketUrl);\n\t        this.stream = Rx_1.Observable.create(function (observer) {\n\t            socket.on(exports.SCENARIO_STATUS_CHANGE_EVENT, function (value) { return observer.next(value); });\n\t        });\n\t    };\n\t    ScenarioStatusService = __decorate([\n\t        core_1.Injectable(), \n\t        __metadata('design:paramtypes', [])\n\t    ], ScenarioStatusService);\n\t    return ScenarioStatusService;\n\t}());\n\texports.ScenarioStatusService = ScenarioStatusService;\n\n\n/***/ },\n\n/***/ 581:\n/***/ function(module, exports) {\n\n\tmodule.exports = \"<div class=\\\"sub-header row\\\">\\n  <div id=\\\"page-title\\\" class=\\\"col s5 sub-header__title\\\"><h2>Scenarios</h2></div>\\n  <div class=\\\"sub-header__actions col s4 right\\\">\\n    <button [routerLink]=\\\"['editor-create']\\\"\\n        class=\\\"waves-effect waves-light btn blue-grey darken-1 sub-header__actions__create\\\">Create new scenario</button>\\n  </div>\\n</div>\\n\\n<div *ngIf=\\\"scenarioList.length === 0\\\" class=\\\"empty-list\\\">\\n    <div class=\\\"container empty-list__container\\\">\\n        <div class=\\\"empty-list__container__text\\\">\\n            <h3 class=\\\"empty-list__container__text__main\\\">There are no scenarios yet</h3>\\n            <h4 class=\\\"empty-list__container__text__additional\\\">Scenarios make your home truly intelligent. Go ahead and create your first scenario.</h4>\\n        </div>\\n    </div>\\n</div>\\n\\n<div *ngIf=\\\"scenarioList.length !== 0\\\" class=\\\"scenario-list\\\">\\n    <table class=\\\"highlight responsive-table scenario-list-table\\\">\\n        <thead class=\\\"scenario-list-table__head\\\">\\n            <th *ngFor=\\\"let header of headers\\\"\\n                class=\\\"scenario-list-table__head__item\\\"\\n                [class.sortable]=\\\"header.sortable\\\">\\n                {{ header.name }}\\n                <div [class]=\\\"reverse ? 'up' : 'down'\\\"></div>\\n            </th>\\n            <th class=\\\"scenario-list-table__head__item\\\">\\n                Actions\\n            </th>\\n        </thead>\\n        <tbody class=\\\"scenario-list-table__body\\\">\\n            <tr *ngFor=\\\"let scenario of scenarioList\\\"\\n                (click)=\\\"navigateToEditView(scenario)\\\"\\n                class=\\\"scenario-list-table__body__row\\\">\\n                <td class=\\\"scenario-list-table__body__row__item\\\">\\n                    <span>{{scenario.name}}</span>\\n                </td>\\n                <td class=\\\"scenario-list-table__body__row__item status\\\">\\n                    <span [class]=\\\"scenario.active ? 'active' : 'paused'\\\">{{scenario.status}}</span>\\n                </td>\\n                <td class=\\\"scenario-list-table__body__row__actions\\\">\\n                    <button (click)=\\\"removeScenario(scenario); $event.stopPropagation()\\\"\\n                            class=\\\"waves-effect waves-light btn scenario-list-table__body__row__actions__remove\\\"\\n                            name=\\\"remove-scenario\\\"\\n                            type=\\\"remove\\\">\\n                        <i class=\\\"material-icons scenario-list-table__body__row__actions__remove__icon\\\">delete</i>\\n                    </button>\\n                    <button (click)=\\\"toggleScenarioState(scenario); $event.stopPropagation()\\\"\\n                            class=\\\"waves-effect waves-light btn scenario-list-table__body__row__actions__toggle-state\\\"\\n                            name=\\\"toggle-scenario-state\\\">\\n                        <i class=\\\"material-icons scenario-list-table__body__row__actions__remove__icon\\\">{{ scenario.active ? 'stop' : 'play_arrow' }}</i>\\n                    </button>\\n                </td>\\n            </tr>\\n        </tbody>\\n    </table>\\n</div>\\n\"\n\n/***/ },\n\n/***/ 582:\n/***/ function(module, exports) {\n\n\tmodule.exports = \".sub-header__actions{vertical-align:middle;line-height:54px}.sub-header__actions__create{width:250px}.empty-list__container{padding:0px}.empty-list__container::before{content:'';display:block;background:url(\\\"./assets/empty-scenarios-list.png\\\") no-repeat;background-size:150px;background-position:calc(100% / 2);height:150px;margin:0 6px 0 0}.empty-list__container__text__main{font-family:Roboto-Regular;font-size:24px;text-align:center}.empty-list__container__text__additional{font-family:Roboto-Regular;font-size:15px;text-align:center}.scenario-list-table__body__row{cursor:pointer}.scenario-list-table__body__row__actions{width:150px}.scenario-list-table__body__row__actions__remove{padding:0 15px}.scenario-list-table__body__row__actions__toggle-state{padding:0 15px}.scenario-list-table__body__row .status span{padding:5px;border-radius:2px}.scenario-list-table__body__row .status span.paused{background:#ffa726}.scenario-list-table__body__row .status span.active{background:#26a69a}\\n\"\n\n/***/ },\n\n/***/ 583:\n/***/ function(module, exports, __webpack_require__) {\n\n\t\"use strict\";\n\tvar __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {\n\t    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;\n\t    if (typeof Reflect === \"object\" && typeof Reflect.decorate === \"function\") r = Reflect.decorate(decorators, target, key, desc);\n\t    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;\n\t    return c > 3 && r && Object.defineProperty(target, key, r), r;\n\t};\n\tvar __metadata = (this && this.__metadata) || function (k, v) {\n\t    if (typeof Reflect === \"object\" && typeof Reflect.metadata === \"function\") return Reflect.metadata(k, v);\n\t};\n\tvar core_1 = __webpack_require__(3);\n\tvar scenario_service_1 = __webpack_require__(565);\n\tvar ScenarioListResolveService = (function () {\n\t    function ScenarioListResolveService(scenarioService) {\n\t        this.scenarioService = scenarioService;\n\t    }\n\t    ScenarioListResolveService.prototype.resolve = function () {\n\t        return this.scenarioService.get();\n\t    };\n\t    ScenarioListResolveService = __decorate([\n\t        core_1.Injectable(), \n\t        __metadata('design:paramtypes', [(typeof (_a = typeof scenario_service_1.ScenarioService !== 'undefined' && scenario_service_1.ScenarioService) === 'function' && _a) || Object])\n\t    ], ScenarioListResolveService);\n\t    return ScenarioListResolveService;\n\t    var _a;\n\t}());\n\texports.ScenarioListResolveService = ScenarioListResolveService;\n\n\n/***/ },\n\n/***/ 584:\n/***/ function(module, exports, __webpack_require__) {\n\n\t\"use strict\";\n\tvar scenario_details_component_1 = __webpack_require__(566);\n\tvar create_scenario_editor_component_1 = __webpack_require__(564);\n\tvar edit_scenario_editor_component_1 = __webpack_require__(572);\n\tvar scenario_editor_component_1 = __webpack_require__(585);\n\tvar create_scenario_wizard_component_1 = __webpack_require__(573);\n\tvar edit_scenario_wizard_component_1 = __webpack_require__(577);\n\tvar scenario_wizard_component_1 = __webpack_require__(597);\n\tvar scenario_list_component_1 = __webpack_require__(579);\n\tObject.defineProperty(exports, \"__esModule\", { value: true });\n\texports.default = [\n\t    scenario_details_component_1.ScenarioDetailsComponent,\n\t    create_scenario_editor_component_1.CreateScenarioEditorComponent,\n\t    edit_scenario_editor_component_1.EditScenarioEditorComponent,\n\t    scenario_editor_component_1.ScenarioEditorComponent,\n\t    create_scenario_wizard_component_1.CreateScenarioWizardComponent,\n\t    edit_scenario_wizard_component_1.EditScenarioWizardComponent,\n\t    scenario_wizard_component_1.ScenarioWizardComponent,\n\t    scenario_list_component_1.ScenarioListComponent\n\t];\n\n\n/***/ },\n\n/***/ 585:\n/***/ function(module, exports, __webpack_require__) {\n\n\t\"use strict\";\n\tvar __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {\n\t    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;\n\t    if (typeof Reflect === \"object\" && typeof Reflect.decorate === \"function\") r = Reflect.decorate(decorators, target, key, desc);\n\t    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;\n\t    return c > 3 && r && Object.defineProperty(target, key, r), r;\n\t};\n\tvar __metadata = (this && this.__metadata) || function (k, v) {\n\t    if (typeof Reflect === \"object\" && typeof Reflect.metadata === \"function\") return Reflect.metadata(k, v);\n\t};\n\tvar core_1 = __webpack_require__(3);\n\t__webpack_require__(586);\n\t__webpack_require__(590);\n\tvar CodeMirror = __webpack_require__(592);\n\t__webpack_require__(593);\n\t__webpack_require__(594);\n\t__webpack_require__(595);\n\tvar code_mirror_events_const_1 = __webpack_require__(596);\n\tvar ScenarioEditorComponent = (function () {\n\t    function ScenarioEditorComponent() {\n\t        this.updateScenario = new core_1.EventEmitter();\n\t        this.codeMirror = CodeMirror;\n\t    }\n\t    ScenarioEditorComponent.prototype.ngAfterViewInit = function () {\n\t        this.initCodeEditor();\n\t    };\n\t    ScenarioEditorComponent.prototype.ngOnChanges = function () {\n\t        if (this.codeEditor && this.scenario !== this.codeEditor.getValue()) {\n\t            this.codeEditor.setValue(this.scenario);\n\t        }\n\t    };\n\t    ScenarioEditorComponent.prototype.initCodeEditor = function () {\n\t        this.codeEditor = this.codeMirror(this.codeEditorElement.nativeElement, {\n\t            mode: 'javascript',\n\t            lineNumbers: true,\n\t            autoCloseBrackets: true,\n\t            matchBrackets: true,\n\t            tabSize: 4,\n\t            theme: 'lesser-dark'\n\t        });\n\t        this.initListeners();\n\t    };\n\t    ScenarioEditorComponent.prototype.initListeners = function () {\n\t        var _this = this;\n\t        this.codeEditor.on('change', function (codeMirror, changeObj) {\n\t            if (changeObj.origin !== code_mirror_events_const_1.default.SET_VALUE_EVENT) {\n\t                var scenarioBody = _this.codeEditor.getValue();\n\t                _this.updateScenario.emit({ scenarioBody: scenarioBody });\n\t            }\n\t        });\n\t    };\n\t    __decorate([\n\t        core_1.ViewChild('codeEditor'), \n\t        __metadata('design:type', Object)\n\t    ], ScenarioEditorComponent.prototype, \"codeEditorElement\", void 0);\n\t    __decorate([\n\t        core_1.Input(), \n\t        __metadata('design:type', String)\n\t    ], ScenarioEditorComponent.prototype, \"scenario\", void 0);\n\t    __decorate([\n\t        core_1.Output(), \n\t        __metadata('design:type', Object)\n\t    ], ScenarioEditorComponent.prototype, \"updateScenario\", void 0);\n\t    ScenarioEditorComponent = __decorate([\n\t        core_1.Component({\n\t            selector: 'sh-scenario-editor',\n\t            template: '<div #codeEditor></div>'\n\t        }), \n\t        __metadata('design:paramtypes', [])\n\t    ], ScenarioEditorComponent);\n\t    return ScenarioEditorComponent;\n\t}());\n\texports.ScenarioEditorComponent = ScenarioEditorComponent;\n\n\n/***/ },\n\n/***/ 586:\n/***/ function(module, exports, __webpack_require__) {\n\n\t// style-loader: Adds some css to the DOM by adding a <style> tag\n\t\n\t// load the styles\n\tvar content = __webpack_require__(587);\n\tif(typeof content === 'string') content = [[module.id, content, '']];\n\t// add the styles to the DOM\n\tvar update = __webpack_require__(589)(content, {});\n\tif(content.locals) module.exports = content.locals;\n\t// Hot Module Replacement\n\tif(false) {\n\t\t// When the styles change, update the <style> tags\n\t\tif(!content.locals) {\n\t\t\tmodule.hot.accept(\"!!../../css-loader/index.js!./codemirror.css\", function() {\n\t\t\t\tvar newContent = require(\"!!../../css-loader/index.js!./codemirror.css\");\n\t\t\t\tif(typeof newContent === 'string') newContent = [[module.id, newContent, '']];\n\t\t\t\tupdate(newContent);\n\t\t\t});\n\t\t}\n\t\t// When the module is disposed, remove the <style> tags\n\t\tmodule.hot.dispose(function() { update(); });\n\t}\n\n/***/ },\n\n/***/ 587:\n/***/ function(module, exports, __webpack_require__) {\n\n\texports = module.exports = __webpack_require__(588)();\n\t// imports\n\t\n\t\n\t// module\n\texports.push([module.id, \".CodeMirror{font-family:monospace;height:300px;color:#000}.CodeMirror-lines{padding:4px 0}.CodeMirror pre{padding:0 4px}.CodeMirror-gutter-filler,.CodeMirror-scrollbar-filler{background-color:#fff}.CodeMirror-gutters{border-right:1px solid #ddd;background-color:#f7f7f7;white-space:nowrap}.CodeMirror-linenumber{padding:0 3px 0 5px;min-width:20px;text-align:right;color:#999;white-space:nowrap}.CodeMirror-guttermarker{color:#000}.CodeMirror-guttermarker-subtle{color:#999}.CodeMirror-cursor{border-left:1px solid #000;border-right:none;width:0}.CodeMirror div.CodeMirror-secondarycursor{border-left:1px solid silver}.cm-fat-cursor .CodeMirror-cursor{width:auto;border:0!important;background:#7e7}.cm-fat-cursor div.CodeMirror-cursors{z-index:1}.cm-animate-fat-cursor{width:auto;border:0;-webkit-animation:blink 1.06s steps(1) infinite;animation:blink 1.06s steps(1) infinite;background-color:#7e7}@-webkit-keyframes blink{50%{background-color:transparent}}@keyframes blink{50%{background-color:transparent}}.cm-tab{display:inline-block;text-decoration:inherit}.CodeMirror-rulers{position:absolute;left:0;right:0;top:-50px;bottom:-20px;overflow:hidden}.CodeMirror-ruler{border-left:1px solid #ccc;top:0;bottom:0;position:absolute}.cm-s-default .cm-header{color:blue}.cm-s-default .cm-quote{color:#090}.cm-negative{color:#d44}.cm-positive{color:#292}.cm-header,.cm-strong{font-weight:700}.cm-em{font-style:italic}.cm-link{text-decoration:underline}.cm-strikethrough{text-decoration:line-through}.cm-s-default .cm-keyword{color:#708}.cm-s-default .cm-atom{color:#219}.cm-s-default .cm-number{color:#164}.cm-s-default .cm-def{color:#00f}.cm-s-default .cm-variable-2{color:#05a}.cm-s-default .cm-variable-3{color:#085}.cm-s-default .cm-comment{color:#a50}.cm-s-default .cm-string{color:#a11}.cm-s-default .cm-string-2{color:#f50}.cm-s-default .cm-meta,.cm-s-default .cm-qualifier{color:#555}.cm-s-default .cm-builtin{color:#30a}.cm-s-default .cm-bracket{color:#997}.cm-s-default .cm-tag{color:#170}.cm-s-default .cm-attribute{color:#00c}.cm-s-default .cm-hr{color:#999}.cm-s-default .cm-link{color:#00c}.cm-invalidchar,.cm-s-default .cm-error{color:red}.CodeMirror-composing{border-bottom:2px solid}div.CodeMirror span.CodeMirror-matchingbracket{color:#0f0}div.CodeMirror span.CodeMirror-nonmatchingbracket{color:#f22}.CodeMirror-matchingtag{background:rgba(255,150,0,.3)}.CodeMirror-activeline-background{background:#e8f2ff}.CodeMirror{position:relative;overflow:hidden;background:#fff}.CodeMirror-scroll{overflow:scroll!important;margin-bottom:-30px;margin-right:-30px;padding-bottom:30px;height:100%;outline:none;position:relative}.CodeMirror-sizer{position:relative;border-right:30px solid transparent}.CodeMirror-gutter-filler,.CodeMirror-hscrollbar,.CodeMirror-scrollbar-filler,.CodeMirror-vscrollbar{position:absolute;z-index:6;display:none}.CodeMirror-vscrollbar{right:0;top:0;overflow-x:hidden;overflow-y:scroll}.CodeMirror-hscrollbar{bottom:0;left:0;overflow-y:hidden;overflow-x:scroll}.CodeMirror-scrollbar-filler{right:0;bottom:0}.CodeMirror-gutter-filler{left:0;bottom:0}.CodeMirror-gutters{position:absolute;left:0;top:0;min-height:100%;z-index:3}.CodeMirror-gutter{white-space:normal;height:100%;display:inline-block;vertical-align:top;margin-bottom:-30px}.CodeMirror-gutter-wrapper{position:absolute;z-index:4;background:none!important;border:none!important}.CodeMirror-gutter-background{position:absolute;top:0;bottom:0;z-index:4}.CodeMirror-gutter-elt{position:absolute;cursor:default;z-index:4}.CodeMirror-gutter-wrapper{-webkit-user-select:none;-moz-user-select:none;user-select:none}.CodeMirror-lines{cursor:text;min-height:1px}.CodeMirror pre{border-radius:0;border-width:0;background:transparent;font-family:inherit;font-size:inherit;margin:0;white-space:pre;word-wrap:normal;line-height:inherit;color:inherit;z-index:2;position:relative;overflow:visible;-webkit-tap-highlight-color:transparent;-webkit-font-variant-ligatures:contextual;font-variant-ligatures:contextual}.CodeMirror-wrap pre{word-wrap:break-word;white-space:pre-wrap;word-break:normal}.CodeMirror-linebackground{position:absolute;left:0;right:0;top:0;bottom:0;z-index:0}.CodeMirror-linewidget{position:relative;z-index:2;overflow:auto}.CodeMirror-code{outline:none}.CodeMirror-gutter,.CodeMirror-gutters,.CodeMirror-linenumber,.CodeMirror-scroll,.CodeMirror-sizer{box-sizing:content-box}.CodeMirror-measure{position:absolute;width:100%;height:0;overflow:hidden;visibility:hidden}.CodeMirror-cursor{position:absolute;pointer-events:none}.CodeMirror-measure pre{position:static}div.CodeMirror-cursors{visibility:hidden;position:relative;z-index:3}.CodeMirror-focused div.CodeMirror-cursors,div.CodeMirror-dragcursors{visibility:visible}.CodeMirror-selected{background:#d9d9d9}.CodeMirror-focused .CodeMirror-selected{background:#d7d4f0}.CodeMirror-crosshair{cursor:crosshair}.CodeMirror-line::selection,.CodeMirror-line>span::selection,.CodeMirror-line>span>span::selection{background:#d7d4f0}.CodeMirror-line::-moz-selection,.CodeMirror-line>span::-moz-selection,.CodeMirror-line>span>span::-moz-selection{background:#d7d4f0}.cm-searching{background:#ffa;background:rgba(255,255,0,.4)}.cm-force-border{padding-right:.1px}@media print{.CodeMirror div.CodeMirror-cursors{visibility:hidden}}.cm-tab-wrap-hack:after{content:\\\"\\\"}span.CodeMirror-selectedtext{background:none}\", \"\"]);\n\t\n\t// exports\n\n\n/***/ },\n\n/***/ 588:\n/***/ function(module, exports) {\n\n\t/*\r\n\t\tMIT License http://www.opensource.org/licenses/mit-license.php\r\n\t\tAuthor Tobias Koppers @sokra\r\n\t*/\r\n\t// css base code, injected by the css-loader\r\n\tmodule.exports = function() {\r\n\t\tvar list = [];\r\n\t\r\n\t\t// return the list of modules as css string\r\n\t\tlist.toString = function toString() {\r\n\t\t\tvar result = [];\r\n\t\t\tfor(var i = 0; i < this.length; i++) {\r\n\t\t\t\tvar item = this[i];\r\n\t\t\t\tif(item[2]) {\r\n\t\t\t\t\tresult.push(\"@media \" + item[2] + \"{\" + item[1] + \"}\");\r\n\t\t\t\t} else {\r\n\t\t\t\t\tresult.push(item[1]);\r\n\t\t\t\t}\r\n\t\t\t}\r\n\t\t\treturn result.join(\"\");\r\n\t\t};\r\n\t\r\n\t\t// import a list of modules into the list\r\n\t\tlist.i = function(modules, mediaQuery) {\r\n\t\t\tif(typeof modules === \"string\")\r\n\t\t\t\tmodules = [[null, modules, \"\"]];\r\n\t\t\tvar alreadyImportedModules = {};\r\n\t\t\tfor(var i = 0; i < this.length; i++) {\r\n\t\t\t\tvar id = this[i][0];\r\n\t\t\t\tif(typeof id === \"number\")\r\n\t\t\t\t\talreadyImportedModules[id] = true;\r\n\t\t\t}\r\n\t\t\tfor(i = 0; i < modules.length; i++) {\r\n\t\t\t\tvar item = modules[i];\r\n\t\t\t\t// skip already imported module\r\n\t\t\t\t// this implementation is not 100% perfect for weird media query combinations\r\n\t\t\t\t//  when a module is imported multiple times with different media queries.\r\n\t\t\t\t//  I hope this will never occur (Hey this way we have smaller bundles)\r\n\t\t\t\tif(typeof item[0] !== \"number\" || !alreadyImportedModules[item[0]]) {\r\n\t\t\t\t\tif(mediaQuery && !item[2]) {\r\n\t\t\t\t\t\titem[2] = mediaQuery;\r\n\t\t\t\t\t} else if(mediaQuery) {\r\n\t\t\t\t\t\titem[2] = \"(\" + item[2] + \") and (\" + mediaQuery + \")\";\r\n\t\t\t\t\t}\r\n\t\t\t\t\tlist.push(item);\r\n\t\t\t\t}\r\n\t\t\t}\r\n\t\t};\r\n\t\treturn list;\r\n\t};\r\n\n\n/***/ },\n\n/***/ 589:\n/***/ function(module, exports, __webpack_require__) {\n\n\t/*\r\n\t\tMIT License http://www.opensource.org/licenses/mit-license.php\r\n\t\tAuthor Tobias Koppers @sokra\r\n\t*/\r\n\tvar stylesInDom = {},\r\n\t\tmemoize = function(fn) {\r\n\t\t\tvar memo;\r\n\t\t\treturn function () {\r\n\t\t\t\tif (typeof memo === \"undefined\") memo = fn.apply(this, arguments);\r\n\t\t\t\treturn memo;\r\n\t\t\t};\r\n\t\t},\r\n\t\tisOldIE = memoize(function() {\r\n\t\t\treturn /msie [6-9]\\b/.test(window.navigator.userAgent.toLowerCase());\r\n\t\t}),\r\n\t\tgetHeadElement = memoize(function () {\r\n\t\t\treturn document.head || document.getElementsByTagName(\"head\")[0];\r\n\t\t}),\r\n\t\tsingletonElement = null,\r\n\t\tsingletonCounter = 0,\r\n\t\tstyleElementsInsertedAtTop = [];\r\n\t\r\n\tmodule.exports = function(list, options) {\r\n\t\tif(true) {\r\n\t\t\tif(typeof document !== \"object\") throw new Error(\"The style-loader cannot be used in a non-browser environment\");\r\n\t\t}\r\n\t\r\n\t\toptions = options || {};\r\n\t\t// Force single-tag solution on IE6-9, which has a hard limit on the # of <style>\r\n\t\t// tags it will allow on a page\r\n\t\tif (typeof options.singleton === \"undefined\") options.singleton = isOldIE();\r\n\t\r\n\t\t// By default, add <style> tags to the bottom of <head>.\r\n\t\tif (typeof options.insertAt === \"undefined\") options.insertAt = \"bottom\";\r\n\t\r\n\t\tvar styles = listToStyles(list);\r\n\t\taddStylesToDom(styles, options);\r\n\t\r\n\t\treturn function update(newList) {\r\n\t\t\tvar mayRemove = [];\r\n\t\t\tfor(var i = 0; i < styles.length; i++) {\r\n\t\t\t\tvar item = styles[i];\r\n\t\t\t\tvar domStyle = stylesInDom[item.id];\r\n\t\t\t\tdomStyle.refs--;\r\n\t\t\t\tmayRemove.push(domStyle);\r\n\t\t\t}\r\n\t\t\tif(newList) {\r\n\t\t\t\tvar newStyles = listToStyles(newList);\r\n\t\t\t\taddStylesToDom(newStyles, options);\r\n\t\t\t}\r\n\t\t\tfor(var i = 0; i < mayRemove.length; i++) {\r\n\t\t\t\tvar domStyle = mayRemove[i];\r\n\t\t\t\tif(domStyle.refs === 0) {\r\n\t\t\t\t\tfor(var j = 0; j < domStyle.parts.length; j++)\r\n\t\t\t\t\t\tdomStyle.parts[j]();\r\n\t\t\t\t\tdelete stylesInDom[domStyle.id];\r\n\t\t\t\t}\r\n\t\t\t}\r\n\t\t};\r\n\t}\r\n\t\r\n\tfunction addStylesToDom(styles, options) {\r\n\t\tfor(var i = 0; i < styles.length; i++) {\r\n\t\t\tvar item = styles[i];\r\n\t\t\tvar domStyle = stylesInDom[item.id];\r\n\t\t\tif(domStyle) {\r\n\t\t\t\tdomStyle.refs++;\r\n\t\t\t\tfor(var j = 0; j < domStyle.parts.length; j++) {\r\n\t\t\t\t\tdomStyle.parts[j](item.parts[j]);\r\n\t\t\t\t}\r\n\t\t\t\tfor(; j < item.parts.length; j++) {\r\n\t\t\t\t\tdomStyle.parts.push(addStyle(item.parts[j], options));\r\n\t\t\t\t}\r\n\t\t\t} else {\r\n\t\t\t\tvar parts = [];\r\n\t\t\t\tfor(var j = 0; j < item.parts.length; j++) {\r\n\t\t\t\t\tparts.push(addStyle(item.parts[j], options));\r\n\t\t\t\t}\r\n\t\t\t\tstylesInDom[item.id] = {id: item.id, refs: 1, parts: parts};\r\n\t\t\t}\r\n\t\t}\r\n\t}\r\n\t\r\n\tfunction listToStyles(list) {\r\n\t\tvar styles = [];\r\n\t\tvar newStyles = {};\r\n\t\tfor(var i = 0; i < list.length; i++) {\r\n\t\t\tvar item = list[i];\r\n\t\t\tvar id = item[0];\r\n\t\t\tvar css = item[1];\r\n\t\t\tvar media = item[2];\r\n\t\t\tvar sourceMap = item[3];\r\n\t\t\tvar part = {css: css, media: media, sourceMap: sourceMap};\r\n\t\t\tif(!newStyles[id])\r\n\t\t\t\tstyles.push(newStyles[id] = {id: id, parts: [part]});\r\n\t\t\telse\r\n\t\t\t\tnewStyles[id].parts.push(part);\r\n\t\t}\r\n\t\treturn styles;\r\n\t}\r\n\t\r\n\tfunction insertStyleElement(options, styleElement) {\r\n\t\tvar head = getHeadElement();\r\n\t\tvar lastStyleElementInsertedAtTop = styleElementsInsertedAtTop[styleElementsInsertedAtTop.length - 1];\r\n\t\tif (options.insertAt === \"top\") {\r\n\t\t\tif(!lastStyleElementInsertedAtTop) {\r\n\t\t\t\thead.insertBefore(styleElement, head.firstChild);\r\n\t\t\t} else if(lastStyleElementInsertedAtTop.nextSibling) {\r\n\t\t\t\thead.insertBefore(styleElement, lastStyleElementInsertedAtTop.nextSibling);\r\n\t\t\t} else {\r\n\t\t\t\thead.appendChild(styleElement);\r\n\t\t\t}\r\n\t\t\tstyleElementsInsertedAtTop.push(styleElement);\r\n\t\t} else if (options.insertAt === \"bottom\") {\r\n\t\t\thead.appendChild(styleElement);\r\n\t\t} else {\r\n\t\t\tthrow new Error(\"Invalid value for parameter 'insertAt'. Must be 'top' or 'bottom'.\");\r\n\t\t}\r\n\t}\r\n\t\r\n\tfunction removeStyleElement(styleElement) {\r\n\t\tstyleElement.parentNode.removeChild(styleElement);\r\n\t\tvar idx = styleElementsInsertedAtTop.indexOf(styleElement);\r\n\t\tif(idx >= 0) {\r\n\t\t\tstyleElementsInsertedAtTop.splice(idx, 1);\r\n\t\t}\r\n\t}\r\n\t\r\n\tfunction createStyleElement(options) {\r\n\t\tvar styleElement = document.createElement(\"style\");\r\n\t\tstyleElement.type = \"text/css\";\r\n\t\tinsertStyleElement(options, styleElement);\r\n\t\treturn styleElement;\r\n\t}\r\n\t\r\n\tfunction createLinkElement(options) {\r\n\t\tvar linkElement = document.createElement(\"link\");\r\n\t\tlinkElement.rel = \"stylesheet\";\r\n\t\tinsertStyleElement(options, linkElement);\r\n\t\treturn linkElement;\r\n\t}\r\n\t\r\n\tfunction addStyle(obj, options) {\r\n\t\tvar styleElement, update, remove;\r\n\t\r\n\t\tif (options.singleton) {\r\n\t\t\tvar styleIndex = singletonCounter++;\r\n\t\t\tstyleElement = singletonElement || (singletonElement = createStyleElement(options));\r\n\t\t\tupdate = applyToSingletonTag.bind(null, styleElement, styleIndex, false);\r\n\t\t\tremove = applyToSingletonTag.bind(null, styleElement, styleIndex, true);\r\n\t\t} else if(obj.sourceMap &&\r\n\t\t\ttypeof URL === \"function\" &&\r\n\t\t\ttypeof URL.createObjectURL === \"function\" &&\r\n\t\t\ttypeof URL.revokeObjectURL === \"function\" &&\r\n\t\t\ttypeof Blob === \"function\" &&\r\n\t\t\ttypeof btoa === \"function\") {\r\n\t\t\tstyleElement = createLinkElement(options);\r\n\t\t\tupdate = updateLink.bind(null, styleElement);\r\n\t\t\tremove = function() {\r\n\t\t\t\tremoveStyleElement(styleElement);\r\n\t\t\t\tif(styleElement.href)\r\n\t\t\t\t\tURL.revokeObjectURL(styleElement.href);\r\n\t\t\t};\r\n\t\t} else {\r\n\t\t\tstyleElement = createStyleElement(options);\r\n\t\t\tupdate = applyToTag.bind(null, styleElement);\r\n\t\t\tremove = function() {\r\n\t\t\t\tremoveStyleElement(styleElement);\r\n\t\t\t};\r\n\t\t}\r\n\t\r\n\t\tupdate(obj);\r\n\t\r\n\t\treturn function updateStyle(newObj) {\r\n\t\t\tif(newObj) {\r\n\t\t\t\tif(newObj.css === obj.css && newObj.media === obj.media && newObj.sourceMap === obj.sourceMap)\r\n\t\t\t\t\treturn;\r\n\t\t\t\tupdate(obj = newObj);\r\n\t\t\t} else {\r\n\t\t\t\tremove();\r\n\t\t\t}\r\n\t\t};\r\n\t}\r\n\t\r\n\tvar replaceText = (function () {\r\n\t\tvar textStore = [];\r\n\t\r\n\t\treturn function (index, replacement) {\r\n\t\t\ttextStore[index] = replacement;\r\n\t\t\treturn textStore.filter(Boolean).join('\\n');\r\n\t\t};\r\n\t})();\r\n\t\r\n\tfunction applyToSingletonTag(styleElement, index, remove, obj) {\r\n\t\tvar css = remove ? \"\" : obj.css;\r\n\t\r\n\t\tif (styleElement.styleSheet) {\r\n\t\t\tstyleElement.styleSheet.cssText = replaceText(index, css);\r\n\t\t} else {\r\n\t\t\tvar cssNode = document.createTextNode(css);\r\n\t\t\tvar childNodes = styleElement.childNodes;\r\n\t\t\tif (childNodes[index]) styleElement.removeChild(childNodes[index]);\r\n\t\t\tif (childNodes.length) {\r\n\t\t\t\tstyleElement.insertBefore(cssNode, childNodes[index]);\r\n\t\t\t} else {\r\n\t\t\t\tstyleElement.appendChild(cssNode);\r\n\t\t\t}\r\n\t\t}\r\n\t}\r\n\t\r\n\tfunction applyToTag(styleElement, obj) {\r\n\t\tvar css = obj.css;\r\n\t\tvar media = obj.media;\r\n\t\r\n\t\tif(media) {\r\n\t\t\tstyleElement.setAttribute(\"media\", media)\r\n\t\t}\r\n\t\r\n\t\tif(styleElement.styleSheet) {\r\n\t\t\tstyleElement.styleSheet.cssText = css;\r\n\t\t} else {\r\n\t\t\twhile(styleElement.firstChild) {\r\n\t\t\t\tstyleElement.removeChild(styleElement.firstChild);\r\n\t\t\t}\r\n\t\t\tstyleElement.appendChild(document.createTextNode(css));\r\n\t\t}\r\n\t}\r\n\t\r\n\tfunction updateLink(linkElement, obj) {\r\n\t\tvar css = obj.css;\r\n\t\tvar sourceMap = obj.sourceMap;\r\n\t\r\n\t\tif(sourceMap) {\r\n\t\t\t// http://stackoverflow.com/a/26603875\r\n\t\t\tcss += \"\\n/*# sourceMappingURL=data:application/json;base64,\" + btoa(unescape(encodeURIComponent(JSON.stringify(sourceMap)))) + \" */\";\r\n\t\t}\r\n\t\r\n\t\tvar blob = new Blob([css], { type: \"text/css\" });\r\n\t\r\n\t\tvar oldSrc = linkElement.href;\r\n\t\r\n\t\tlinkElement.href = URL.createObjectURL(blob);\r\n\t\r\n\t\tif(oldSrc)\r\n\t\t\tURL.revokeObjectURL(oldSrc);\r\n\t}\r\n\n\n/***/ },\n\n/***/ 590:\n/***/ function(module, exports, __webpack_require__) {\n\n\t// style-loader: Adds some css to the DOM by adding a <style> tag\n\t\n\t// load the styles\n\tvar content = __webpack_require__(591);\n\tif(typeof content === 'string') content = [[module.id, content, '']];\n\t// add the styles to the DOM\n\tvar update = __webpack_require__(589)(content, {});\n\tif(content.locals) module.exports = content.locals;\n\t// Hot Module Replacement\n\tif(false) {\n\t\t// When the styles change, update the <style> tags\n\t\tif(!content.locals) {\n\t\t\tmodule.hot.accept(\"!!../../css-loader/index.js!./lesser-dark.css\", function() {\n\t\t\t\tvar newContent = require(\"!!../../css-loader/index.js!./lesser-dark.css\");\n\t\t\t\tif(typeof newContent === 'string') newContent = [[module.id, newContent, '']];\n\t\t\t\tupdate(newContent);\n\t\t\t});\n\t\t}\n\t\t// When the module is disposed, remove the <style> tags\n\t\tmodule.hot.dispose(function() { update(); });\n\t}\n\n/***/ },\n\n/***/ 591:\n/***/ function(module, exports, __webpack_require__) {\n\n\texports = module.exports = __webpack_require__(588)();\n\t// imports\n\t\n\t\n\t// module\n\texports.push([module.id, \".cm-s-lesser-dark{line-height:1.3em}.cm-s-lesser-dark.CodeMirror{background:#262626;color:#ebefe7;text-shadow:0 -1px 1px #262626}.cm-s-lesser-dark div.CodeMirror-selected{background:#45443b}.cm-s-lesser-dark .CodeMirror-line::selection,.cm-s-lesser-dark .CodeMirror-line>span::selection,.cm-s-lesser-dark .CodeMirror-line>span>span::selection{background:rgba(69,68,59,.99)}.cm-s-lesser-dark .CodeMirror-line::-moz-selection,.cm-s-lesser-dark .CodeMirror-line>span::-moz-selection,.cm-s-lesser-dark .CodeMirror-line>span>span::-moz-selection{background:rgba(69,68,59,.99)}.cm-s-lesser-dark .CodeMirror-cursor{border-left:1px solid #fff}.cm-s-lesser-dark pre{padding:0 8px}.cm-s-lesser-dark.CodeMirror span.CodeMirror-matchingbracket{color:#7efc7e}.cm-s-lesser-dark .CodeMirror-gutters{background:#262626;border-right:1px solid #aaa}.cm-s-lesser-dark .CodeMirror-guttermarker{color:#599eff}.cm-s-lesser-dark .CodeMirror-guttermarker-subtle,.cm-s-lesser-dark .CodeMirror-linenumber{color:#777}.cm-s-lesser-dark span.cm-header{color:#a0a}.cm-s-lesser-dark span.cm-quote{color:#090}.cm-s-lesser-dark span.cm-keyword{color:#599eff}.cm-s-lesser-dark span.cm-atom{color:#c2b470}.cm-s-lesser-dark span.cm-number{color:#b35e4d}.cm-s-lesser-dark span.cm-def{color:#fff}.cm-s-lesser-dark span.cm-variable{color:#d9bf8c}.cm-s-lesser-dark span.cm-variable-2{color:#669199}.cm-s-lesser-dark span.cm-variable-3{color:#fff}.cm-s-lesser-dark span.cm-operator,.cm-s-lesser-dark span.cm-property{color:#92a75c}.cm-s-lesser-dark span.cm-comment{color:#666}.cm-s-lesser-dark span.cm-string{color:#bcd279}.cm-s-lesser-dark span.cm-string-2{color:#f50}.cm-s-lesser-dark span.cm-meta{color:#738c73}.cm-s-lesser-dark span.cm-qualifier{color:#555}.cm-s-lesser-dark span.cm-builtin{color:#ff9e59}.cm-s-lesser-dark span.cm-bracket{color:#ebefe7}.cm-s-lesser-dark span.cm-tag{color:#669199}.cm-s-lesser-dark span.cm-attribute{color:#00c}.cm-s-lesser-dark span.cm-hr{color:#999}.cm-s-lesser-dark span.cm-link{color:#00c}.cm-s-lesser-dark span.cm-error{color:#9d1e15}.cm-s-lesser-dark .CodeMirror-activeline-background{background:#3c3a3a}.cm-s-lesser-dark .CodeMirror-matchingbracket{outline:1px solid grey;color:#fff!important}\", \"\"]);\n\t\n\t// exports\n\n\n/***/ },\n\n/***/ 592:\n/***/ function(module, exports, __webpack_require__) {\n\n\t// CodeMirror, copyright (c) by Marijn Haverbeke and others\n\t// Distributed under an MIT license: http://codemirror.net/LICENSE\n\t\n\t// This is CodeMirror (http://codemirror.net), a code editor\n\t// implemented in JavaScript on top of the browser's DOM.\n\t//\n\t// You can find some technical background for some of the code below\n\t// at http://marijnhaverbeke.nl/blog/#cm-internals .\n\t\n\t(function (global, factory) {\n\t   true ? module.exports = factory() :\n\t  typeof define === 'function' && define.amd ? define(factory) :\n\t  (global.CodeMirror = factory());\n\t}(this, (function () { 'use strict';\n\t\n\t// Kludges for bugs and behavior differences that can't be feature\n\t// detected are enabled based on userAgent etc sniffing.\n\tvar userAgent = navigator.userAgent\n\tvar platform = navigator.platform\n\t\n\tvar gecko = /gecko\\/\\d/i.test(userAgent)\n\tvar ie_upto10 = /MSIE \\d/.test(userAgent)\n\tvar ie_11up = /Trident\\/(?:[7-9]|\\d{2,})\\..*rv:(\\d+)/.exec(userAgent)\n\tvar edge = /Edge\\/(\\d+)/.exec(userAgent)\n\tvar ie = ie_upto10 || ie_11up || edge\n\tvar ie_version = ie && (ie_upto10 ? document.documentMode || 6 : +(edge || ie_11up)[1])\n\tvar webkit = !edge && /WebKit\\//.test(userAgent)\n\tvar qtwebkit = webkit && /Qt\\/\\d+\\.\\d+/.test(userAgent)\n\tvar chrome = !edge && /Chrome\\//.test(userAgent)\n\tvar presto = /Opera\\//.test(userAgent)\n\tvar safari = /Apple Computer/.test(navigator.vendor)\n\tvar mac_geMountainLion = /Mac OS X 1\\d\\D([8-9]|\\d\\d)\\D/.test(userAgent)\n\tvar phantom = /PhantomJS/.test(userAgent)\n\t\n\tvar ios = !edge && /AppleWebKit/.test(userAgent) && /Mobile\\/\\w+/.test(userAgent)\n\t// This is woefully incomplete. Suggestions for alternative methods welcome.\n\tvar mobile = ios || /Android|webOS|BlackBerry|Opera Mini|Opera Mobi|IEMobile/i.test(userAgent)\n\tvar mac = ios || /Mac/.test(platform)\n\tvar chromeOS = /\\bCrOS\\b/.test(userAgent)\n\tvar windows = /win/i.test(platform)\n\t\n\tvar presto_version = presto && userAgent.match(/Version\\/(\\d*\\.\\d*)/)\n\tif (presto_version) { presto_version = Number(presto_version[1]) }\n\tif (presto_version && presto_version >= 15) { presto = false; webkit = true }\n\t// Some browsers use the wrong event properties to signal cmd/ctrl on OS X\n\tvar flipCtrlCmd = mac && (qtwebkit || presto && (presto_version == null || presto_version < 12.11))\n\tvar captureRightClick = gecko || (ie && ie_version >= 9)\n\t\n\tfunction classTest(cls) { return new RegExp(\"(^|\\\\s)\" + cls + \"(?:$|\\\\s)\\\\s*\") }\n\t\n\tvar rmClass = function(node, cls) {\n\t  var current = node.className\n\t  var match = classTest(cls).exec(current)\n\t  if (match) {\n\t    var after = current.slice(match.index + match[0].length)\n\t    node.className = current.slice(0, match.index) + (after ? match[1] + after : \"\")\n\t  }\n\t}\n\t\n\tfunction removeChildren(e) {\n\t  for (var count = e.childNodes.length; count > 0; --count)\n\t    { e.removeChild(e.firstChild) }\n\t  return e\n\t}\n\t\n\tfunction removeChildrenAndAdd(parent, e) {\n\t  return removeChildren(parent).appendChild(e)\n\t}\n\t\n\tfunction elt(tag, content, className, style) {\n\t  var e = document.createElement(tag)\n\t  if (className) { e.className = className }\n\t  if (style) { e.style.cssText = style }\n\t  if (typeof content == \"string\") { e.appendChild(document.createTextNode(content)) }\n\t  else if (content) { for (var i = 0; i < content.length; ++i) { e.appendChild(content[i]) } }\n\t  return e\n\t}\n\t\n\tvar range\n\tif (document.createRange) { range = function(node, start, end, endNode) {\n\t  var r = document.createRange()\n\t  r.setEnd(endNode || node, end)\n\t  r.setStart(node, start)\n\t  return r\n\t} }\n\telse { range = function(node, start, end) {\n\t  var r = document.body.createTextRange()\n\t  try { r.moveToElementText(node.parentNode) }\n\t  catch(e) { return r }\n\t  r.collapse(true)\n\t  r.moveEnd(\"character\", end)\n\t  r.moveStart(\"character\", start)\n\t  return r\n\t} }\n\t\n\tfunction contains(parent, child) {\n\t  if (child.nodeType == 3) // Android browser always returns false when child is a textnode\n\t    { child = child.parentNode }\n\t  if (parent.contains)\n\t    { return parent.contains(child) }\n\t  do {\n\t    if (child.nodeType == 11) { child = child.host }\n\t    if (child == parent) { return true }\n\t  } while (child = child.parentNode)\n\t}\n\t\n\tfunction activeElt() {\n\t  // IE and Edge may throw an \"Unspecified Error\" when accessing document.activeElement.\n\t  // IE < 10 will throw when accessed while the page is loading or in an iframe.\n\t  // IE > 9 and Edge will throw when accessed in an iframe if document.body is unavailable.\n\t  var activeElement\n\t  try {\n\t    activeElement = document.activeElement\n\t  } catch(e) {\n\t    activeElement = document.body || null\n\t  }\n\t  while (activeElement && activeElement.root && activeElement.root.activeElement)\n\t    { activeElement = activeElement.root.activeElement }\n\t  return activeElement\n\t}\n\t\n\tfunction addClass(node, cls) {\n\t  var current = node.className\n\t  if (!classTest(cls).test(current)) { node.className += (current ? \" \" : \"\") + cls }\n\t}\n\tfunction joinClasses(a, b) {\n\t  var as = a.split(\" \")\n\t  for (var i = 0; i < as.length; i++)\n\t    { if (as[i] && !classTest(as[i]).test(b)) { b += \" \" + as[i] } }\n\t  return b\n\t}\n\t\n\tvar selectInput = function(node) { node.select() }\n\tif (ios) // Mobile Safari apparently has a bug where select() is broken.\n\t  { selectInput = function(node) { node.selectionStart = 0; node.selectionEnd = node.value.length } }\n\telse if (ie) // Suppress mysterious IE10 errors\n\t  { selectInput = function(node) { try { node.select() } catch(_e) {} } }\n\t\n\tfunction bind(f) {\n\t  var args = Array.prototype.slice.call(arguments, 1)\n\t  return function(){return f.apply(null, args)}\n\t}\n\t\n\tfunction copyObj(obj, target, overwrite) {\n\t  if (!target) { target = {} }\n\t  for (var prop in obj)\n\t    { if (obj.hasOwnProperty(prop) && (overwrite !== false || !target.hasOwnProperty(prop)))\n\t      { target[prop] = obj[prop] } }\n\t  return target\n\t}\n\t\n\t// Counts the column offset in a string, taking tabs into account.\n\t// Used mostly to find indentation.\n\tfunction countColumn(string, end, tabSize, startIndex, startValue) {\n\t  if (end == null) {\n\t    end = string.search(/[^\\s\\u00a0]/)\n\t    if (end == -1) { end = string.length }\n\t  }\n\t  for (var i = startIndex || 0, n = startValue || 0;;) {\n\t    var nextTab = string.indexOf(\"\\t\", i)\n\t    if (nextTab < 0 || nextTab >= end)\n\t      { return n + (end - i) }\n\t    n += nextTab - i\n\t    n += tabSize - (n % tabSize)\n\t    i = nextTab + 1\n\t  }\n\t}\n\t\n\tvar Delayed = function() {this.id = null};\n\tDelayed.prototype.set = function (ms, f) {\n\t  clearTimeout(this.id)\n\t  this.id = setTimeout(f, ms)\n\t};\n\t\n\tfunction indexOf(array, elt) {\n\t  for (var i = 0; i < array.length; ++i)\n\t    { if (array[i] == elt) { return i } }\n\t  return -1\n\t}\n\t\n\t// Number of pixels added to scroller and sizer to hide scrollbar\n\tvar scrollerGap = 30\n\t\n\t// Returned or thrown by various protocols to signal 'I'm not\n\t// handling this'.\n\tvar Pass = {toString: function(){return \"CodeMirror.Pass\"}}\n\t\n\t// Reused option objects for setSelection & friends\n\tvar sel_dontScroll = {scroll: false};\n\tvar sel_mouse = {origin: \"*mouse\"};\n\tvar sel_move = {origin: \"+move\"};\n\t// The inverse of countColumn -- find the offset that corresponds to\n\t// a particular column.\n\tfunction findColumn(string, goal, tabSize) {\n\t  for (var pos = 0, col = 0;;) {\n\t    var nextTab = string.indexOf(\"\\t\", pos)\n\t    if (nextTab == -1) { nextTab = string.length }\n\t    var skipped = nextTab - pos\n\t    if (nextTab == string.length || col + skipped >= goal)\n\t      { return pos + Math.min(skipped, goal - col) }\n\t    col += nextTab - pos\n\t    col += tabSize - (col % tabSize)\n\t    pos = nextTab + 1\n\t    if (col >= goal) { return pos }\n\t  }\n\t}\n\t\n\tvar spaceStrs = [\"\"]\n\tfunction spaceStr(n) {\n\t  while (spaceStrs.length <= n)\n\t    { spaceStrs.push(lst(spaceStrs) + \" \") }\n\t  return spaceStrs[n]\n\t}\n\t\n\tfunction lst(arr) { return arr[arr.length-1] }\n\t\n\tfunction map(array, f) {\n\t  var out = []\n\t  for (var i = 0; i < array.length; i++) { out[i] = f(array[i], i) }\n\t  return out\n\t}\n\t\n\tfunction insertSorted(array, value, score) {\n\t  var pos = 0, priority = score(value)\n\t  while (pos < array.length && score(array[pos]) <= priority) { pos++ }\n\t  array.splice(pos, 0, value)\n\t}\n\t\n\tfunction nothing() {}\n\t\n\tfunction createObj(base, props) {\n\t  var inst\n\t  if (Object.create) {\n\t    inst = Object.create(base)\n\t  } else {\n\t    nothing.prototype = base\n\t    inst = new nothing()\n\t  }\n\t  if (props) { copyObj(props, inst) }\n\t  return inst\n\t}\n\t\n\tvar nonASCIISingleCaseWordChar = /[\\u00df\\u0587\\u0590-\\u05f4\\u0600-\\u06ff\\u3040-\\u309f\\u30a0-\\u30ff\\u3400-\\u4db5\\u4e00-\\u9fcc\\uac00-\\ud7af]/\n\tfunction isWordCharBasic(ch) {\n\t  return /\\w/.test(ch) || ch > \"\\x80\" &&\n\t    (ch.toUpperCase() != ch.toLowerCase() || nonASCIISingleCaseWordChar.test(ch))\n\t}\n\tfunction isWordChar(ch, helper) {\n\t  if (!helper) { return isWordCharBasic(ch) }\n\t  if (helper.source.indexOf(\"\\\\w\") > -1 && isWordCharBasic(ch)) { return true }\n\t  return helper.test(ch)\n\t}\n\t\n\tfunction isEmpty(obj) {\n\t  for (var n in obj) { if (obj.hasOwnProperty(n) && obj[n]) { return false } }\n\t  return true\n\t}\n\t\n\t// Extending unicode characters. A series of a non-extending char +\n\t// any number of extending chars is treated as a single unit as far\n\t// as editing and measuring is concerned. This is not fully correct,\n\t// since some scripts/fonts/browsers also treat other configurations\n\t// of code points as a group.\n\tvar extendingChars = /[\\u0300-\\u036f\\u0483-\\u0489\\u0591-\\u05bd\\u05bf\\u05c1\\u05c2\\u05c4\\u05c5\\u05c7\\u0610-\\u061a\\u064b-\\u065e\\u0670\\u06d6-\\u06dc\\u06de-\\u06e4\\u06e7\\u06e8\\u06ea-\\u06ed\\u0711\\u0730-\\u074a\\u07a6-\\u07b0\\u07eb-\\u07f3\\u0816-\\u0819\\u081b-\\u0823\\u0825-\\u0827\\u0829-\\u082d\\u0900-\\u0902\\u093c\\u0941-\\u0948\\u094d\\u0951-\\u0955\\u0962\\u0963\\u0981\\u09bc\\u09be\\u09c1-\\u09c4\\u09cd\\u09d7\\u09e2\\u09e3\\u0a01\\u0a02\\u0a3c\\u0a41\\u0a42\\u0a47\\u0a48\\u0a4b-\\u0a4d\\u0a51\\u0a70\\u0a71\\u0a75\\u0a81\\u0a82\\u0abc\\u0ac1-\\u0ac5\\u0ac7\\u0ac8\\u0acd\\u0ae2\\u0ae3\\u0b01\\u0b3c\\u0b3e\\u0b3f\\u0b41-\\u0b44\\u0b4d\\u0b56\\u0b57\\u0b62\\u0b63\\u0b82\\u0bbe\\u0bc0\\u0bcd\\u0bd7\\u0c3e-\\u0c40\\u0c46-\\u0c48\\u0c4a-\\u0c4d\\u0c55\\u0c56\\u0c62\\u0c63\\u0cbc\\u0cbf\\u0cc2\\u0cc6\\u0ccc\\u0ccd\\u0cd5\\u0cd6\\u0ce2\\u0ce3\\u0d3e\\u0d41-\\u0d44\\u0d4d\\u0d57\\u0d62\\u0d63\\u0dca\\u0dcf\\u0dd2-\\u0dd4\\u0dd6\\u0ddf\\u0e31\\u0e34-\\u0e3a\\u0e47-\\u0e4e\\u0eb1\\u0eb4-\\u0eb9\\u0ebb\\u0ebc\\u0ec8-\\u0ecd\\u0f18\\u0f19\\u0f35\\u0f37\\u0f39\\u0f71-\\u0f7e\\u0f80-\\u0f84\\u0f86\\u0f87\\u0f90-\\u0f97\\u0f99-\\u0fbc\\u0fc6\\u102d-\\u1030\\u1032-\\u1037\\u1039\\u103a\\u103d\\u103e\\u1058\\u1059\\u105e-\\u1060\\u1071-\\u1074\\u1082\\u1085\\u1086\\u108d\\u109d\\u135f\\u1712-\\u1714\\u1732-\\u1734\\u1752\\u1753\\u1772\\u1773\\u17b7-\\u17bd\\u17c6\\u17c9-\\u17d3\\u17dd\\u180b-\\u180d\\u18a9\\u1920-\\u1922\\u1927\\u1928\\u1932\\u1939-\\u193b\\u1a17\\u1a18\\u1a56\\u1a58-\\u1a5e\\u1a60\\u1a62\\u1a65-\\u1a6c\\u1a73-\\u1a7c\\u1a7f\\u1b00-\\u1b03\\u1b34\\u1b36-\\u1b3a\\u1b3c\\u1b42\\u1b6b-\\u1b73\\u1b80\\u1b81\\u1ba2-\\u1ba5\\u1ba8\\u1ba9\\u1c2c-\\u1c33\\u1c36\\u1c37\\u1cd0-\\u1cd2\\u1cd4-\\u1ce0\\u1ce2-\\u1ce8\\u1ced\\u1dc0-\\u1de6\\u1dfd-\\u1dff\\u200c\\u200d\\u20d0-\\u20f0\\u2cef-\\u2cf1\\u2de0-\\u2dff\\u302a-\\u302f\\u3099\\u309a\\ua66f-\\ua672\\ua67c\\ua67d\\ua6f0\\ua6f1\\ua802\\ua806\\ua80b\\ua825\\ua826\\ua8c4\\ua8e0-\\ua8f1\\ua926-\\ua92d\\ua947-\\ua951\\ua980-\\ua982\\ua9b3\\ua9b6-\\ua9b9\\ua9bc\\uaa29-\\uaa2e\\uaa31\\uaa32\\uaa35\\uaa36\\uaa43\\uaa4c\\uaab0\\uaab2-\\uaab4\\uaab7\\uaab8\\uaabe\\uaabf\\uaac1\\uabe5\\uabe8\\uabed\\udc00-\\udfff\\ufb1e\\ufe00-\\ufe0f\\ufe20-\\ufe26\\uff9e\\uff9f]/\n\tfunction isExtendingChar(ch) { return ch.charCodeAt(0) >= 768 && extendingChars.test(ch) }\n\t\n\t// Returns a number from the range [`0`; `str.length`] unless `pos` is outside that range.\n\tfunction skipExtendingChars(str, pos, dir) {\n\t  while ((dir < 0 ? pos > 0 : pos < str.length) && isExtendingChar(str.charAt(pos))) { pos += dir }\n\t  return pos\n\t}\n\t\n\t// Returns the value from the range [`from`; `to`] that satisfies\n\t// `pred` and is closest to `from`. Assumes that at least `to` satisfies `pred`.\n\tfunction findFirst(pred, from, to) {\n\t  for (;;) {\n\t    if (Math.abs(from - to) <= 1) { return pred(from) ? from : to }\n\t    var mid = Math.floor((from + to) / 2)\n\t    if (pred(mid)) { to = mid }\n\t    else { from = mid }\n\t  }\n\t}\n\t\n\t// The display handles the DOM integration, both for input reading\n\t// and content drawing. It holds references to DOM nodes and\n\t// display-related state.\n\t\n\tfunction Display(place, doc, input) {\n\t  var d = this\n\t  this.input = input\n\t\n\t  // Covers bottom-right square when both scrollbars are present.\n\t  d.scrollbarFiller = elt(\"div\", null, \"CodeMirror-scrollbar-filler\")\n\t  d.scrollbarFiller.setAttribute(\"cm-not-content\", \"true\")\n\t  // Covers bottom of gutter when coverGutterNextToScrollbar is on\n\t  // and h scrollbar is present.\n\t  d.gutterFiller = elt(\"div\", null, \"CodeMirror-gutter-filler\")\n\t  d.gutterFiller.setAttribute(\"cm-not-content\", \"true\")\n\t  // Will contain the actual code, positioned to cover the viewport.\n\t  d.lineDiv = elt(\"div\", null, \"CodeMirror-code\")\n\t  // Elements are added to these to represent selection and cursors.\n\t  d.selectionDiv = elt(\"div\", null, null, \"position: relative; z-index: 1\")\n\t  d.cursorDiv = elt(\"div\", null, \"CodeMirror-cursors\")\n\t  // A visibility: hidden element used to find the size of things.\n\t  d.measure = elt(\"div\", null, \"CodeMirror-measure\")\n\t  // When lines outside of the viewport are measured, they are drawn in this.\n\t  d.lineMeasure = elt(\"div\", null, \"CodeMirror-measure\")\n\t  // Wraps everything that needs to exist inside the vertically-padded coordinate system\n\t  d.lineSpace = elt(\"div\", [d.measure, d.lineMeasure, d.selectionDiv, d.cursorDiv, d.lineDiv],\n\t                    null, \"position: relative; outline: none\")\n\t  // Moved around its parent to cover visible view.\n\t  d.mover = elt(\"div\", [elt(\"div\", [d.lineSpace], \"CodeMirror-lines\")], null, \"position: relative\")\n\t  // Set to the height of the document, allowing scrolling.\n\t  d.sizer = elt(\"div\", [d.mover], \"CodeMirror-sizer\")\n\t  d.sizerWidth = null\n\t  // Behavior of elts with overflow: auto and padding is\n\t  // inconsistent across browsers. This is used to ensure the\n\t  // scrollable area is big enough.\n\t  d.heightForcer = elt(\"div\", null, null, \"position: absolute; height: \" + scrollerGap + \"px; width: 1px;\")\n\t  // Will contain the gutters, if any.\n\t  d.gutters = elt(\"div\", null, \"CodeMirror-gutters\")\n\t  d.lineGutter = null\n\t  // Actual scrollable element.\n\t  d.scroller = elt(\"div\", [d.sizer, d.heightForcer, d.gutters], \"CodeMirror-scroll\")\n\t  d.scroller.setAttribute(\"tabIndex\", \"-1\")\n\t  // The element in which the editor lives.\n\t  d.wrapper = elt(\"div\", [d.scrollbarFiller, d.gutterFiller, d.scroller], \"CodeMirror\")\n\t\n\t  // Work around IE7 z-index bug (not perfect, hence IE7 not really being supported)\n\t  if (ie && ie_version < 8) { d.gutters.style.zIndex = -1; d.scroller.style.paddingRight = 0 }\n\t  if (!webkit && !(gecko && mobile)) { d.scroller.draggable = true }\n\t\n\t  if (place) {\n\t    if (place.appendChild) { place.appendChild(d.wrapper) }\n\t    else { place(d.wrapper) }\n\t  }\n\t\n\t  // Current rendered range (may be bigger than the view window).\n\t  d.viewFrom = d.viewTo = doc.first\n\t  d.reportedViewFrom = d.reportedViewTo = doc.first\n\t  // Information about the rendered lines.\n\t  d.view = []\n\t  d.renderedView = null\n\t  // Holds info about a single rendered line when it was rendered\n\t  // for measurement, while not in view.\n\t  d.externalMeasured = null\n\t  // Empty space (in pixels) above the view\n\t  d.viewOffset = 0\n\t  d.lastWrapHeight = d.lastWrapWidth = 0\n\t  d.updateLineNumbers = null\n\t\n\t  d.nativeBarWidth = d.barHeight = d.barWidth = 0\n\t  d.scrollbarsClipped = false\n\t\n\t  // Used to only resize the line number gutter when necessary (when\n\t  // the amount of lines crosses a boundary that makes its width change)\n\t  d.lineNumWidth = d.lineNumInnerWidth = d.lineNumChars = null\n\t  // Set to true when a non-horizontal-scrolling line widget is\n\t  // added. As an optimization, line widget aligning is skipped when\n\t  // this is false.\n\t  d.alignWidgets = false\n\t\n\t  d.cachedCharWidth = d.cachedTextHeight = d.cachedPaddingH = null\n\t\n\t  // Tracks the maximum line length so that the horizontal scrollbar\n\t  // can be kept static when scrolling.\n\t  d.maxLine = null\n\t  d.maxLineLength = 0\n\t  d.maxLineChanged = false\n\t\n\t  // Used for measuring wheel scrolling granularity\n\t  d.wheelDX = d.wheelDY = d.wheelStartX = d.wheelStartY = null\n\t\n\t  // True when shift is held down.\n\t  d.shift = false\n\t\n\t  // Used to track whether anything happened since the context menu\n\t  // was opened.\n\t  d.selForContextMenu = null\n\t\n\t  d.activeTouch = null\n\t\n\t  input.init(d)\n\t}\n\t\n\t// Find the line object corresponding to the given line number.\n\tfunction getLine(doc, n) {\n\t  n -= doc.first\n\t  if (n < 0 || n >= doc.size) { throw new Error(\"There is no line \" + (n + doc.first) + \" in the document.\") }\n\t  var chunk = doc\n\t  while (!chunk.lines) {\n\t    for (var i = 0;; ++i) {\n\t      var child = chunk.children[i], sz = child.chunkSize()\n\t      if (n < sz) { chunk = child; break }\n\t      n -= sz\n\t    }\n\t  }\n\t  return chunk.lines[n]\n\t}\n\t\n\t// Get the part of a document between two positions, as an array of\n\t// strings.\n\tfunction getBetween(doc, start, end) {\n\t  var out = [], n = start.line\n\t  doc.iter(start.line, end.line + 1, function (line) {\n\t    var text = line.text\n\t    if (n == end.line) { text = text.slice(0, end.ch) }\n\t    if (n == start.line) { text = text.slice(start.ch) }\n\t    out.push(text)\n\t    ++n\n\t  })\n\t  return out\n\t}\n\t// Get the lines between from and to, as array of strings.\n\tfunction getLines(doc, from, to) {\n\t  var out = []\n\t  doc.iter(from, to, function (line) { out.push(line.text) }) // iter aborts when callback returns truthy value\n\t  return out\n\t}\n\t\n\t// Update the height of a line, propagating the height change\n\t// upwards to parent nodes.\n\tfunction updateLineHeight(line, height) {\n\t  var diff = height - line.height\n\t  if (diff) { for (var n = line; n; n = n.parent) { n.height += diff } }\n\t}\n\t\n\t// Given a line object, find its line number by walking up through\n\t// its parent links.\n\tfunction lineNo(line) {\n\t  if (line.parent == null) { return null }\n\t  var cur = line.parent, no = indexOf(cur.lines, line)\n\t  for (var chunk = cur.parent; chunk; cur = chunk, chunk = chunk.parent) {\n\t    for (var i = 0;; ++i) {\n\t      if (chunk.children[i] == cur) { break }\n\t      no += chunk.children[i].chunkSize()\n\t    }\n\t  }\n\t  return no + cur.first\n\t}\n\t\n\t// Find the line at the given vertical position, using the height\n\t// information in the document tree.\n\tfunction lineAtHeight(chunk, h) {\n\t  var n = chunk.first\n\t  outer: do {\n\t    for (var i$1 = 0; i$1 < chunk.children.length; ++i$1) {\n\t      var child = chunk.children[i$1], ch = child.height\n\t      if (h < ch) { chunk = child; continue outer }\n\t      h -= ch\n\t      n += child.chunkSize()\n\t    }\n\t    return n\n\t  } while (!chunk.lines)\n\t  var i = 0\n\t  for (; i < chunk.lines.length; ++i) {\n\t    var line = chunk.lines[i], lh = line.height\n\t    if (h < lh) { break }\n\t    h -= lh\n\t  }\n\t  return n + i\n\t}\n\t\n\tfunction isLine(doc, l) {return l >= doc.first && l < doc.first + doc.size}\n\t\n\tfunction lineNumberFor(options, i) {\n\t  return String(options.lineNumberFormatter(i + options.firstLineNumber))\n\t}\n\t\n\t// A Pos instance represents a position within the text.\n\tfunction Pos(line, ch, sticky) {\n\t  if ( sticky === void 0 ) sticky = null;\n\t\n\t  if (!(this instanceof Pos)) { return new Pos(line, ch, sticky) }\n\t  this.line = line\n\t  this.ch = ch\n\t  this.sticky = sticky\n\t}\n\t\n\t// Compare two positions, return 0 if they are the same, a negative\n\t// number when a is less, and a positive number otherwise.\n\tfunction cmp(a, b) { return a.line - b.line || a.ch - b.ch }\n\t\n\tfunction equalCursorPos(a, b) { return a.sticky == b.sticky && cmp(a, b) == 0 }\n\t\n\tfunction copyPos(x) {return Pos(x.line, x.ch)}\n\tfunction maxPos(a, b) { return cmp(a, b) < 0 ? b : a }\n\tfunction minPos(a, b) { return cmp(a, b) < 0 ? a : b }\n\t\n\t// Most of the external API clips given positions to make sure they\n\t// actually exist within the document.\n\tfunction clipLine(doc, n) {return Math.max(doc.first, Math.min(n, doc.first + doc.size - 1))}\n\tfunction clipPos(doc, pos) {\n\t  if (pos.line < doc.first) { return Pos(doc.first, 0) }\n\t  var last = doc.first + doc.size - 1\n\t  if (pos.line > last) { return Pos(last, getLine(doc, last).text.length) }\n\t  return clipToLen(pos, getLine(doc, pos.line).text.length)\n\t}\n\tfunction clipToLen(pos, linelen) {\n\t  var ch = pos.ch\n\t  if (ch == null || ch > linelen) { return Pos(pos.line, linelen) }\n\t  else if (ch < 0) { return Pos(pos.line, 0) }\n\t  else { return pos }\n\t}\n\tfunction clipPosArray(doc, array) {\n\t  var out = []\n\t  for (var i = 0; i < array.length; i++) { out[i] = clipPos(doc, array[i]) }\n\t  return out\n\t}\n\t\n\t// Optimize some code when these features are not used.\n\tvar sawReadOnlySpans = false;\n\tvar sawCollapsedSpans = false;\n\tfunction seeReadOnlySpans() {\n\t  sawReadOnlySpans = true\n\t}\n\t\n\tfunction seeCollapsedSpans() {\n\t  sawCollapsedSpans = true\n\t}\n\t\n\t// TEXTMARKER SPANS\n\t\n\tfunction MarkedSpan(marker, from, to) {\n\t  this.marker = marker\n\t  this.from = from; this.to = to\n\t}\n\t\n\t// Search an array of spans for a span matching the given marker.\n\tfunction getMarkedSpanFor(spans, marker) {\n\t  if (spans) { for (var i = 0; i < spans.length; ++i) {\n\t    var span = spans[i]\n\t    if (span.marker == marker) { return span }\n\t  } }\n\t}\n\t// Remove a span from an array, returning undefined if no spans are\n\t// left (we don't store arrays for lines without spans).\n\tfunction removeMarkedSpan(spans, span) {\n\t  var r\n\t  for (var i = 0; i < spans.length; ++i)\n\t    { if (spans[i] != span) { (r || (r = [])).push(spans[i]) } }\n\t  return r\n\t}\n\t// Add a span to a line.\n\tfunction addMarkedSpan(line, span) {\n\t  line.markedSpans = line.markedSpans ? line.markedSpans.concat([span]) : [span]\n\t  span.marker.attachLine(line)\n\t}\n\t\n\t// Used for the algorithm that adjusts markers for a change in the\n\t// document. These functions cut an array of spans at a given\n\t// character position, returning an array of remaining chunks (or\n\t// undefined if nothing remains).\n\tfunction markedSpansBefore(old, startCh, isInsert) {\n\t  var nw\n\t  if (old) { for (var i = 0; i < old.length; ++i) {\n\t    var span = old[i], marker = span.marker\n\t    var startsBefore = span.from == null || (marker.inclusiveLeft ? span.from <= startCh : span.from < startCh)\n\t    if (startsBefore || span.from == startCh && marker.type == \"bookmark\" && (!isInsert || !span.marker.insertLeft)) {\n\t      var endsAfter = span.to == null || (marker.inclusiveRight ? span.to >= startCh : span.to > startCh)\n\t      ;(nw || (nw = [])).push(new MarkedSpan(marker, span.from, endsAfter ? null : span.to))\n\t    }\n\t  } }\n\t  return nw\n\t}\n\tfunction markedSpansAfter(old, endCh, isInsert) {\n\t  var nw\n\t  if (old) { for (var i = 0; i < old.length; ++i) {\n\t    var span = old[i], marker = span.marker\n\t    var endsAfter = span.to == null || (marker.inclusiveRight ? span.to >= endCh : span.to > endCh)\n\t    if (endsAfter || span.from == endCh && marker.type == \"bookmark\" && (!isInsert || span.marker.insertLeft)) {\n\t      var startsBefore = span.from == null || (marker.inclusiveLeft ? span.from <= endCh : span.from < endCh)\n\t      ;(nw || (nw = [])).push(new MarkedSpan(marker, startsBefore ? null : span.from - endCh,\n\t                                            span.to == null ? null : span.to - endCh))\n\t    }\n\t  } }\n\t  return nw\n\t}\n\t\n\t// Given a change object, compute the new set of marker spans that\n\t// cover the line in which the change took place. Removes spans\n\t// entirely within the change, reconnects spans belonging to the\n\t// same marker that appear on both sides of the change, and cuts off\n\t// spans partially within the change. Returns an array of span\n\t// arrays with one element for each line in (after) the change.\n\tfunction stretchSpansOverChange(doc, change) {\n\t  if (change.full) { return null }\n\t  var oldFirst = isLine(doc, change.from.line) && getLine(doc, change.from.line).markedSpans\n\t  var oldLast = isLine(doc, change.to.line) && getLine(doc, change.to.line).markedSpans\n\t  if (!oldFirst && !oldLast) { return null }\n\t\n\t  var startCh = change.from.ch, endCh = change.to.ch, isInsert = cmp(change.from, change.to) == 0\n\t  // Get the spans that 'stick out' on both sides\n\t  var first = markedSpansBefore(oldFirst, startCh, isInsert)\n\t  var last = markedSpansAfter(oldLast, endCh, isInsert)\n\t\n\t  // Next, merge those two ends\n\t  var sameLine = change.text.length == 1, offset = lst(change.text).length + (sameLine ? startCh : 0)\n\t  if (first) {\n\t    // Fix up .to properties of first\n\t    for (var i = 0; i < first.length; ++i) {\n\t      var span = first[i]\n\t      if (span.to == null) {\n\t        var found = getMarkedSpanFor(last, span.marker)\n\t        if (!found) { span.to = startCh }\n\t        else if (sameLine) { span.to = found.to == null ? null : found.to + offset }\n\t      }\n\t    }\n\t  }\n\t  if (last) {\n\t    // Fix up .from in last (or move them into first in case of sameLine)\n\t    for (var i$1 = 0; i$1 < last.length; ++i$1) {\n\t      var span$1 = last[i$1]\n\t      if (span$1.to != null) { span$1.to += offset }\n\t      if (span$1.from == null) {\n\t        var found$1 = getMarkedSpanFor(first, span$1.marker)\n\t        if (!found$1) {\n\t          span$1.from = offset\n\t          if (sameLine) { (first || (first = [])).push(span$1) }\n\t        }\n\t      } else {\n\t        span$1.from += offset\n\t        if (sameLine) { (first || (first = [])).push(span$1) }\n\t      }\n\t    }\n\t  }\n\t  // Make sure we didn't create any zero-length spans\n\t  if (first) { first = clearEmptySpans(first) }\n\t  if (last && last != first) { last = clearEmptySpans(last) }\n\t\n\t  var newMarkers = [first]\n\t  if (!sameLine) {\n\t    // Fill gap with whole-line-spans\n\t    var gap = change.text.length - 2, gapMarkers\n\t    if (gap > 0 && first)\n\t      { for (var i$2 = 0; i$2 < first.length; ++i$2)\n\t        { if (first[i$2].to == null)\n\t          { (gapMarkers || (gapMarkers = [])).push(new MarkedSpan(first[i$2].marker, null, null)) } } }\n\t    for (var i$3 = 0; i$3 < gap; ++i$3)\n\t      { newMarkers.push(gapMarkers) }\n\t    newMarkers.push(last)\n\t  }\n\t  return newMarkers\n\t}\n\t\n\t// Remove spans that are empty and don't have a clearWhenEmpty\n\t// option of false.\n\tfunction clearEmptySpans(spans) {\n\t  for (var i = 0; i < spans.length; ++i) {\n\t    var span = spans[i]\n\t    if (span.from != null && span.from == span.to && span.marker.clearWhenEmpty !== false)\n\t      { spans.splice(i--, 1) }\n\t  }\n\t  if (!spans.length) { return null }\n\t  return spans\n\t}\n\t\n\t// Used to 'clip' out readOnly ranges when making a change.\n\tfunction removeReadOnlyRanges(doc, from, to) {\n\t  var markers = null\n\t  doc.iter(from.line, to.line + 1, function (line) {\n\t    if (line.markedSpans) { for (var i = 0; i < line.markedSpans.length; ++i) {\n\t      var mark = line.markedSpans[i].marker\n\t      if (mark.readOnly && (!markers || indexOf(markers, mark) == -1))\n\t        { (markers || (markers = [])).push(mark) }\n\t    } }\n\t  })\n\t  if (!markers) { return null }\n\t  var parts = [{from: from, to: to}]\n\t  for (var i = 0; i < markers.length; ++i) {\n\t    var mk = markers[i], m = mk.find(0)\n\t    for (var j = 0; j < parts.length; ++j) {\n\t      var p = parts[j]\n\t      if (cmp(p.to, m.from) < 0 || cmp(p.from, m.to) > 0) { continue }\n\t      var newParts = [j, 1], dfrom = cmp(p.from, m.from), dto = cmp(p.to, m.to)\n\t      if (dfrom < 0 || !mk.inclusiveLeft && !dfrom)\n\t        { newParts.push({from: p.from, to: m.from}) }\n\t      if (dto > 0 || !mk.inclusiveRight && !dto)\n\t        { newParts.push({from: m.to, to: p.to}) }\n\t      parts.splice.apply(parts, newParts)\n\t      j += newParts.length - 3\n\t    }\n\t  }\n\t  return parts\n\t}\n\t\n\t// Connect or disconnect spans from a line.\n\tfunction detachMarkedSpans(line) {\n\t  var spans = line.markedSpans\n\t  if (!spans) { return }\n\t  for (var i = 0; i < spans.length; ++i)\n\t    { spans[i].marker.detachLine(line) }\n\t  line.markedSpans = null\n\t}\n\tfunction attachMarkedSpans(line, spans) {\n\t  if (!spans) { return }\n\t  for (var i = 0; i < spans.length; ++i)\n\t    { spans[i].marker.attachLine(line) }\n\t  line.markedSpans = spans\n\t}\n\t\n\t// Helpers used when computing which overlapping collapsed span\n\t// counts as the larger one.\n\tfunction extraLeft(marker) { return marker.inclusiveLeft ? -1 : 0 }\n\tfunction extraRight(marker) { return marker.inclusiveRight ? 1 : 0 }\n\t\n\t// Returns a number indicating which of two overlapping collapsed\n\t// spans is larger (and thus includes the other). Falls back to\n\t// comparing ids when the spans cover exactly the same range.\n\tfunction compareCollapsedMarkers(a, b) {\n\t  var lenDiff = a.lines.length - b.lines.length\n\t  if (lenDiff != 0) { return lenDiff }\n\t  var aPos = a.find(), bPos = b.find()\n\t  var fromCmp = cmp(aPos.from, bPos.from) || extraLeft(a) - extraLeft(b)\n\t  if (fromCmp) { return -fromCmp }\n\t  var toCmp = cmp(aPos.to, bPos.to) || extraRight(a) - extraRight(b)\n\t  if (toCmp) { return toCmp }\n\t  return b.id - a.id\n\t}\n\t\n\t// Find out whether a line ends or starts in a collapsed span. If\n\t// so, return the marker for that span.\n\tfunction collapsedSpanAtSide(line, start) {\n\t  var sps = sawCollapsedSpans && line.markedSpans, found\n\t  if (sps) { for (var sp = (void 0), i = 0; i < sps.length; ++i) {\n\t    sp = sps[i]\n\t    if (sp.marker.collapsed && (start ? sp.from : sp.to) == null &&\n\t        (!found || compareCollapsedMarkers(found, sp.marker) < 0))\n\t      { found = sp.marker }\n\t  } }\n\t  return found\n\t}\n\tfunction collapsedSpanAtStart(line) { return collapsedSpanAtSide(line, true) }\n\tfunction collapsedSpanAtEnd(line) { return collapsedSpanAtSide(line, false) }\n\t\n\t// Test whether there exists a collapsed span that partially\n\t// overlaps (covers the start or end, but not both) of a new span.\n\t// Such overlap is not allowed.\n\tfunction conflictingCollapsedRange(doc, lineNo, from, to, marker) {\n\t  var line = getLine(doc, lineNo)\n\t  var sps = sawCollapsedSpans && line.markedSpans\n\t  if (sps) { for (var i = 0; i < sps.length; ++i) {\n\t    var sp = sps[i]\n\t    if (!sp.marker.collapsed) { continue }\n\t    var found = sp.marker.find(0)\n\t    var fromCmp = cmp(found.from, from) || extraLeft(sp.marker) - extraLeft(marker)\n\t    var toCmp = cmp(found.to, to) || extraRight(sp.marker) - extraRight(marker)\n\t    if (fromCmp >= 0 && toCmp <= 0 || fromCmp <= 0 && toCmp >= 0) { continue }\n\t    if (fromCmp <= 0 && (sp.marker.inclusiveRight && marker.inclusiveLeft ? cmp(found.to, from) >= 0 : cmp(found.to, from) > 0) ||\n\t        fromCmp >= 0 && (sp.marker.inclusiveRight && marker.inclusiveLeft ? cmp(found.from, to) <= 0 : cmp(found.from, to) < 0))\n\t      { return true }\n\t  } }\n\t}\n\t\n\t// A visual line is a line as drawn on the screen. Folding, for\n\t// example, can cause multiple logical lines to appear on the same\n\t// visual line. This finds the start of the visual line that the\n\t// given line is part of (usually that is the line itself).\n\tfunction visualLine(line) {\n\t  var merged\n\t  while (merged = collapsedSpanAtStart(line))\n\t    { line = merged.find(-1, true).line }\n\t  return line\n\t}\n\t\n\tfunction visualLineEnd(line) {\n\t  var merged\n\t  while (merged = collapsedSpanAtEnd(line))\n\t    { line = merged.find(1, true).line }\n\t  return line\n\t}\n\t\n\t// Returns an array of logical lines that continue the visual line\n\t// started by the argument, or undefined if there are no such lines.\n\tfunction visualLineContinued(line) {\n\t  var merged, lines\n\t  while (merged = collapsedSpanAtEnd(line)) {\n\t    line = merged.find(1, true).line\n\t    ;(lines || (lines = [])).push(line)\n\t  }\n\t  return lines\n\t}\n\t\n\t// Get the line number of the start of the visual line that the\n\t// given line number is part of.\n\tfunction visualLineNo(doc, lineN) {\n\t  var line = getLine(doc, lineN), vis = visualLine(line)\n\t  if (line == vis) { return lineN }\n\t  return lineNo(vis)\n\t}\n\t\n\t// Get the line number of the start of the next visual line after\n\t// the given line.\n\tfunction visualLineEndNo(doc, lineN) {\n\t  if (lineN > doc.lastLine()) { return lineN }\n\t  var line = getLine(doc, lineN), merged\n\t  if (!lineIsHidden(doc, line)) { return lineN }\n\t  while (merged = collapsedSpanAtEnd(line))\n\t    { line = merged.find(1, true).line }\n\t  return lineNo(line) + 1\n\t}\n\t\n\t// Compute whether a line is hidden. Lines count as hidden when they\n\t// are part of a visual line that starts with another line, or when\n\t// they are entirely covered by collapsed, non-widget span.\n\tfunction lineIsHidden(doc, line) {\n\t  var sps = sawCollapsedSpans && line.markedSpans\n\t  if (sps) { for (var sp = (void 0), i = 0; i < sps.length; ++i) {\n\t    sp = sps[i]\n\t    if (!sp.marker.collapsed) { continue }\n\t    if (sp.from == null) { return true }\n\t    if (sp.marker.widgetNode) { continue }\n\t    if (sp.from == 0 && sp.marker.inclusiveLeft && lineIsHiddenInner(doc, line, sp))\n\t      { return true }\n\t  } }\n\t}\n\tfunction lineIsHiddenInner(doc, line, span) {\n\t  if (span.to == null) {\n\t    var end = span.marker.find(1, true)\n\t    return lineIsHiddenInner(doc, end.line, getMarkedSpanFor(end.line.markedSpans, span.marker))\n\t  }\n\t  if (span.marker.inclusiveRight && span.to == line.text.length)\n\t    { return true }\n\t  for (var sp = (void 0), i = 0; i < line.markedSpans.length; ++i) {\n\t    sp = line.markedSpans[i]\n\t    if (sp.marker.collapsed && !sp.marker.widgetNode && sp.from == span.to &&\n\t        (sp.to == null || sp.to != span.from) &&\n\t        (sp.marker.inclusiveLeft || span.marker.inclusiveRight) &&\n\t        lineIsHiddenInner(doc, line, sp)) { return true }\n\t  }\n\t}\n\t\n\t// Find the height above the given line.\n\tfunction heightAtLine(lineObj) {\n\t  lineObj = visualLine(lineObj)\n\t\n\t  var h = 0, chunk = lineObj.parent\n\t  for (var i = 0; i < chunk.lines.length; ++i) {\n\t    var line = chunk.lines[i]\n\t    if (line == lineObj) { break }\n\t    else { h += line.height }\n\t  }\n\t  for (var p = chunk.parent; p; chunk = p, p = chunk.parent) {\n\t    for (var i$1 = 0; i$1 < p.children.length; ++i$1) {\n\t      var cur = p.children[i$1]\n\t      if (cur == chunk) { break }\n\t      else { h += cur.height }\n\t    }\n\t  }\n\t  return h\n\t}\n\t\n\t// Compute the character length of a line, taking into account\n\t// collapsed ranges (see markText) that might hide parts, and join\n\t// other lines onto it.\n\tfunction lineLength(line) {\n\t  if (line.height == 0) { return 0 }\n\t  var len = line.text.length, merged, cur = line\n\t  while (merged = collapsedSpanAtStart(cur)) {\n\t    var found = merged.find(0, true)\n\t    cur = found.from.line\n\t    len += found.from.ch - found.to.ch\n\t  }\n\t  cur = line\n\t  while (merged = collapsedSpanAtEnd(cur)) {\n\t    var found$1 = merged.find(0, true)\n\t    len -= cur.text.length - found$1.from.ch\n\t    cur = found$1.to.line\n\t    len += cur.text.length - found$1.to.ch\n\t  }\n\t  return len\n\t}\n\t\n\t// Find the longest line in the document.\n\tfunction findMaxLine(cm) {\n\t  var d = cm.display, doc = cm.doc\n\t  d.maxLine = getLine(doc, doc.first)\n\t  d.maxLineLength = lineLength(d.maxLine)\n\t  d.maxLineChanged = true\n\t  doc.iter(function (line) {\n\t    var len = lineLength(line)\n\t    if (len > d.maxLineLength) {\n\t      d.maxLineLength = len\n\t      d.maxLine = line\n\t    }\n\t  })\n\t}\n\t\n\t// BIDI HELPERS\n\t\n\tfunction iterateBidiSections(order, from, to, f) {\n\t  if (!order) { return f(from, to, \"ltr\") }\n\t  var found = false\n\t  for (var i = 0; i < order.length; ++i) {\n\t    var part = order[i]\n\t    if (part.from < to && part.to > from || from == to && part.to == from) {\n\t      f(Math.max(part.from, from), Math.min(part.to, to), part.level == 1 ? \"rtl\" : \"ltr\")\n\t      found = true\n\t    }\n\t  }\n\t  if (!found) { f(from, to, \"ltr\") }\n\t}\n\t\n\tvar bidiOther = null\n\tfunction getBidiPartAt(order, ch, sticky) {\n\t  var found\n\t  bidiOther = null\n\t  for (var i = 0; i < order.length; ++i) {\n\t    var cur = order[i]\n\t    if (cur.from < ch && cur.to > ch) { return i }\n\t    if (cur.to == ch) {\n\t      if (cur.from != cur.to && sticky == \"before\") { found = i }\n\t      else { bidiOther = i }\n\t    }\n\t    if (cur.from == ch) {\n\t      if (cur.from != cur.to && sticky != \"before\") { found = i }\n\t      else { bidiOther = i }\n\t    }\n\t  }\n\t  return found != null ? found : bidiOther\n\t}\n\t\n\t// Bidirectional ordering algorithm\n\t// See http://unicode.org/reports/tr9/tr9-13.html for the algorithm\n\t// that this (partially) implements.\n\t\n\t// One-char codes used for character types:\n\t// L (L):   Left-to-Right\n\t// R (R):   Right-to-Left\n\t// r (AL):  Right-to-Left Arabic\n\t// 1 (EN):  European Number\n\t// + (ES):  European Number Separator\n\t// % (ET):  European Number Terminator\n\t// n (AN):  Arabic Number\n\t// , (CS):  Common Number Separator\n\t// m (NSM): Non-Spacing Mark\n\t// b (BN):  Boundary Neutral\n\t// s (B):   Paragraph Separator\n\t// t (S):   Segment Separator\n\t// w (WS):  Whitespace\n\t// N (ON):  Other Neutrals\n\t\n\t// Returns null if characters are ordered as they appear\n\t// (left-to-right), or an array of sections ({from, to, level}\n\t// objects) in the order in which they occur visually.\n\tvar bidiOrdering = (function() {\n\t  // Character types for codepoints 0 to 0xff\n\t  var lowTypes = \"bbbbbbbbbtstwsbbbbbbbbbbbbbbssstwNN%%%NNNNNN,N,N1111111111NNNNNNNLLLLLLLLLLLLLLLLLLLLLLLLLLNNNNNNLLLLLLLLLLLLLLLLLLLLLLLLLLNNNNbbbbbbsbbbbbbbbbbbbbbbbbbbbbbbbbb,N%%%%NNNNLNNNNN%%11NLNNN1LNNNNNLLLLLLLLLLLLLLLLLLLLLLLNLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLN\"\n\t  // Character types for codepoints 0x600 to 0x6f9\n\t  var arabicTypes = \"nnnnnnNNr%%r,rNNmmmmmmmmmmmrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrmmmmmmmmmmmmmmmmmmmmmnnnnnnnnnn%nnrrrmrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrmmmmmmmnNmmmmmmrrmmNmmmmrr1111111111\"\n\t  function charType(code) {\n\t    if (code <= 0xf7) { return lowTypes.charAt(code) }\n\t    else if (0x590 <= code && code <= 0x5f4) { return \"R\" }\n\t    else if (0x600 <= code && code <= 0x6f9) { return arabicTypes.charAt(code - 0x600) }\n\t    else if (0x6ee <= code && code <= 0x8ac) { return \"r\" }\n\t    else if (0x2000 <= code && code <= 0x200b) { return \"w\" }\n\t    else if (code == 0x200c) { return \"b\" }\n\t    else { return \"L\" }\n\t  }\n\t\n\t  var bidiRE = /[\\u0590-\\u05f4\\u0600-\\u06ff\\u0700-\\u08ac]/\n\t  var isNeutral = /[stwN]/, isStrong = /[LRr]/, countsAsLeft = /[Lb1n]/, countsAsNum = /[1n]/\n\t  // Browsers seem to always treat the boundaries of block elements as being L.\n\t  var outerType = \"L\"\n\t\n\t  function BidiSpan(level, from, to) {\n\t    this.level = level\n\t    this.from = from; this.to = to\n\t  }\n\t\n\t  return function(str) {\n\t    if (!bidiRE.test(str)) { return false }\n\t    var len = str.length, types = []\n\t    for (var i = 0; i < len; ++i)\n\t      { types.push(charType(str.charCodeAt(i))) }\n\t\n\t    // W1. Examine each non-spacing mark (NSM) in the level run, and\n\t    // change the type of the NSM to the type of the previous\n\t    // character. If the NSM is at the start of the level run, it will\n\t    // get the type of sor.\n\t    for (var i$1 = 0, prev = outerType; i$1 < len; ++i$1) {\n\t      var type = types[i$1]\n\t      if (type == \"m\") { types[i$1] = prev }\n\t      else { prev = type }\n\t    }\n\t\n\t    // W2. Search backwards from each instance of a European number\n\t    // until the first strong type (R, L, AL, or sor) is found. If an\n\t    // AL is found, change the type of the European number to Arabic\n\t    // number.\n\t    // W3. Change all ALs to R.\n\t    for (var i$2 = 0, cur = outerType; i$2 < len; ++i$2) {\n\t      var type$1 = types[i$2]\n\t      if (type$1 == \"1\" && cur == \"r\") { types[i$2] = \"n\" }\n\t      else if (isStrong.test(type$1)) { cur = type$1; if (type$1 == \"r\") { types[i$2] = \"R\" } }\n\t    }\n\t\n\t    // W4. A single European separator between two European numbers\n\t    // changes to a European number. A single common separator between\n\t    // two numbers of the same type changes to that type.\n\t    for (var i$3 = 1, prev$1 = types[0]; i$3 < len - 1; ++i$3) {\n\t      var type$2 = types[i$3]\n\t      if (type$2 == \"+\" && prev$1 == \"1\" && types[i$3+1] == \"1\") { types[i$3] = \"1\" }\n\t      else if (type$2 == \",\" && prev$1 == types[i$3+1] &&\n\t               (prev$1 == \"1\" || prev$1 == \"n\")) { types[i$3] = prev$1 }\n\t      prev$1 = type$2\n\t    }\n\t\n\t    // W5. A sequence of European terminators adjacent to European\n\t    // numbers changes to all European numbers.\n\t    // W6. Otherwise, separators and terminators change to Other\n\t    // Neutral.\n\t    for (var i$4 = 0; i$4 < len; ++i$4) {\n\t      var type$3 = types[i$4]\n\t      if (type$3 == \",\") { types[i$4] = \"N\" }\n\t      else if (type$3 == \"%\") {\n\t        var end = (void 0)\n\t        for (end = i$4 + 1; end < len && types[end] == \"%\"; ++end) {}\n\t        var replace = (i$4 && types[i$4-1] == \"!\") || (end < len && types[end] == \"1\") ? \"1\" : \"N\"\n\t        for (var j = i$4; j < end; ++j) { types[j] = replace }\n\t        i$4 = end - 1\n\t      }\n\t    }\n\t\n\t    // W7. Search backwards from each instance of a European number\n\t    // until the first strong type (R, L, or sor) is found. If an L is\n\t    // found, then change the type of the European number to L.\n\t    for (var i$5 = 0, cur$1 = outerType; i$5 < len; ++i$5) {\n\t      var type$4 = types[i$5]\n\t      if (cur$1 == \"L\" && type$4 == \"1\") { types[i$5] = \"L\" }\n\t      else if (isStrong.test(type$4)) { cur$1 = type$4 }\n\t    }\n\t\n\t    // N1. A sequence of neutrals takes the direction of the\n\t    // surrounding strong text if the text on both sides has the same\n\t    // direction. European and Arabic numbers act as if they were R in\n\t    // terms of their influence on neutrals. Start-of-level-run (sor)\n\t    // and end-of-level-run (eor) are used at level run boundaries.\n\t    // N2. Any remaining neutrals take the embedding direction.\n\t    for (var i$6 = 0; i$6 < len; ++i$6) {\n\t      if (isNeutral.test(types[i$6])) {\n\t        var end$1 = (void 0)\n\t        for (end$1 = i$6 + 1; end$1 < len && isNeutral.test(types[end$1]); ++end$1) {}\n\t        var before = (i$6 ? types[i$6-1] : outerType) == \"L\"\n\t        var after = (end$1 < len ? types[end$1] : outerType) == \"L\"\n\t        var replace$1 = before || after ? \"L\" : \"R\"\n\t        for (var j$1 = i$6; j$1 < end$1; ++j$1) { types[j$1] = replace$1 }\n\t        i$6 = end$1 - 1\n\t      }\n\t    }\n\t\n\t    // Here we depart from the documented algorithm, in order to avoid\n\t    // building up an actual levels array. Since there are only three\n\t    // levels (0, 1, 2) in an implementation that doesn't take\n\t    // explicit embedding into account, we can build up the order on\n\t    // the fly, without following the level-based algorithm.\n\t    var order = [], m\n\t    for (var i$7 = 0; i$7 < len;) {\n\t      if (countsAsLeft.test(types[i$7])) {\n\t        var start = i$7\n\t        for (++i$7; i$7 < len && countsAsLeft.test(types[i$7]); ++i$7) {}\n\t        order.push(new BidiSpan(0, start, i$7))\n\t      } else {\n\t        var pos = i$7, at = order.length\n\t        for (++i$7; i$7 < len && types[i$7] != \"L\"; ++i$7) {}\n\t        for (var j$2 = pos; j$2 < i$7;) {\n\t          if (countsAsNum.test(types[j$2])) {\n\t            if (pos < j$2) { order.splice(at, 0, new BidiSpan(1, pos, j$2)) }\n\t            var nstart = j$2\n\t            for (++j$2; j$2 < i$7 && countsAsNum.test(types[j$2]); ++j$2) {}\n\t            order.splice(at, 0, new BidiSpan(2, nstart, j$2))\n\t            pos = j$2\n\t          } else { ++j$2 }\n\t        }\n\t        if (pos < i$7) { order.splice(at, 0, new BidiSpan(1, pos, i$7)) }\n\t      }\n\t    }\n\t    if (order[0].level == 1 && (m = str.match(/^\\s+/))) {\n\t      order[0].from = m[0].length\n\t      order.unshift(new BidiSpan(0, 0, m[0].length))\n\t    }\n\t    if (lst(order).level == 1 && (m = str.match(/\\s+$/))) {\n\t      lst(order).to -= m[0].length\n\t      order.push(new BidiSpan(0, len - m[0].length, len))\n\t    }\n\t\n\t    return order\n\t  }\n\t})()\n\t\n\t// Get the bidi ordering for the given line (and cache it). Returns\n\t// false for lines that are fully left-to-right, and an array of\n\t// BidiSpan objects otherwise.\n\tfunction getOrder(line) {\n\t  var order = line.order\n\t  if (order == null) { order = line.order = bidiOrdering(line.text) }\n\t  return order\n\t}\n\t\n\tfunction moveCharLogically(line, ch, dir) {\n\t  var target = skipExtendingChars(line.text, ch + dir, dir)\n\t  return target < 0 || target > line.text.length ? null : target\n\t}\n\t\n\tfunction moveLogically(line, start, dir) {\n\t  var ch = moveCharLogically(line, start.ch, dir)\n\t  return ch == null ? null : new Pos(start.line, ch, dir < 0 ? \"after\" : \"before\")\n\t}\n\t\n\tfunction endOfLine(visually, cm, lineObj, lineNo, dir) {\n\t  if (visually) {\n\t    var order = getOrder(lineObj)\n\t    if (order) {\n\t      var part = dir < 0 ? lst(order) : order[0]\n\t      var moveInStorageOrder = (dir < 0) == (part.level == 1)\n\t      var sticky = moveInStorageOrder ? \"after\" : \"before\"\n\t      var ch\n\t      // With a wrapped rtl chunk (possibly spanning multiple bidi parts),\n\t      // it could be that the last bidi part is not on the last visual line,\n\t      // since visual lines contain content order-consecutive chunks.\n\t      // Thus, in rtl, we are looking for the first (content-order) character\n\t      // in the rtl chunk that is on the last line (that is, the same line\n\t      // as the last (content-order) character).\n\t      if (part.level > 0) {\n\t        var prep = prepareMeasureForLine(cm, lineObj)\n\t        ch = dir < 0 ? lineObj.text.length - 1 : 0\n\t        var targetTop = measureCharPrepared(cm, prep, ch).top\n\t        ch = findFirst(function (ch) { return measureCharPrepared(cm, prep, ch).top == targetTop; }, (dir < 0) == (part.level == 1) ? part.from : part.to - 1, ch)\n\t        if (sticky == \"before\") { ch = moveCharLogically(lineObj, ch, 1, true) }\n\t      } else { ch = dir < 0 ? part.to : part.from }\n\t      return new Pos(lineNo, ch, sticky)\n\t    }\n\t  }\n\t  return new Pos(lineNo, dir < 0 ? lineObj.text.length : 0, dir < 0 ? \"before\" : \"after\")\n\t}\n\t\n\tfunction moveVisually(cm, line, start, dir) {\n\t  var bidi = getOrder(line)\n\t  if (!bidi) { return moveLogically(line, start, dir) }\n\t  if (start.ch >= line.text.length) {\n\t    start.ch = line.text.length\n\t    start.sticky = \"before\"\n\t  } else if (start.ch <= 0) {\n\t    start.ch = 0\n\t    start.sticky = \"after\"\n\t  }\n\t  var partPos = getBidiPartAt(bidi, start.ch, start.sticky), part = bidi[partPos]\n\t  if (part.level % 2 == 0 && (dir > 0 ? part.to > start.ch : part.from < start.ch)) {\n\t    // Case 1: We move within an ltr part. Even with wrapped lines,\n\t    // nothing interesting happens.\n\t    return moveLogically(line, start, dir)\n\t  }\n\t\n\t  var mv = function (pos, dir) { return moveCharLogically(line, pos instanceof Pos ? pos.ch : pos, dir); }\n\t  var prep\n\t  var getWrappedLineExtent = function (ch) {\n\t    if (!cm.options.lineWrapping) { return {begin: 0, end: line.text.length} }\n\t    prep = prep || prepareMeasureForLine(cm, line)\n\t    return wrappedLineExtentChar(cm, line, prep, ch)\n\t  }\n\t  var wrappedLineExtent = getWrappedLineExtent(start.sticky == \"before\" ? mv(start, -1) : start.ch)\n\t\n\t  if (part.level % 2 == 1) {\n\t    var ch = mv(start, -dir)\n\t    if (ch != null && (dir > 0 ? ch >= part.from && ch >= wrappedLineExtent.begin : ch <= part.to && ch <= wrappedLineExtent.end)) {\n\t      // Case 2: We move within an rtl part on the same visual line\n\t      var sticky = dir < 0 ? \"before\" : \"after\"\n\t      return new Pos(start.line, ch, sticky)\n\t    }\n\t  }\n\t\n\t  // Case 3: Could not move within this bidi part in this visual line, so leave\n\t  // the current bidi part\n\t\n\t  var searchInVisualLine = function (partPos, dir, wrappedLineExtent) {\n\t    var getRes = function (ch, moveInStorageOrder) { return moveInStorageOrder\n\t      ? new Pos(start.line, mv(ch, 1), \"before\")\n\t      : new Pos(start.line, ch, \"after\"); }\n\t\n\t    for (; partPos >= 0 && partPos < bidi.length; partPos += dir) {\n\t      var part = bidi[partPos]\n\t      var moveInStorageOrder = (dir > 0) == (part.level != 1)\n\t      var ch = moveInStorageOrder ? wrappedLineExtent.begin : mv(wrappedLineExtent.end, -1)\n\t      if (part.from <= ch && ch < part.to) { return getRes(ch, moveInStorageOrder) }\n\t      ch = moveInStorageOrder ? part.from : mv(part.to, -1)\n\t      if (wrappedLineExtent.begin <= ch && ch < wrappedLineExtent.end) { return getRes(ch, moveInStorageOrder) }\n\t    }\n\t  }\n\t\n\t  // Case 3a: Look for other bidi parts on the same visual line\n\t  var res = searchInVisualLine(partPos + dir, dir, wrappedLineExtent)\n\t  if (res) { return res }\n\t\n\t  // Case 3b: Look for other bidi parts on the next visual line\n\t  var nextCh = dir > 0 ? wrappedLineExtent.end : mv(wrappedLineExtent.begin, -1)\n\t  if (nextCh != null && !(dir > 0 && nextCh == line.text.length)) {\n\t    res = searchInVisualLine(dir > 0 ? 0 : bidi.length - 1, dir, getWrappedLineExtent(nextCh))\n\t    if (res) { return res }\n\t  }\n\t\n\t  // Case 4: Nowhere to move\n\t  return null\n\t}\n\t\n\t// EVENT HANDLING\n\t\n\t// Lightweight event framework. on/off also work on DOM nodes,\n\t// registering native DOM handlers.\n\t\n\tvar noHandlers = []\n\t\n\tvar on = function(emitter, type, f) {\n\t  if (emitter.addEventListener) {\n\t    emitter.addEventListener(type, f, false)\n\t  } else if (emitter.attachEvent) {\n\t    emitter.attachEvent(\"on\" + type, f)\n\t  } else {\n\t    var map = emitter._handlers || (emitter._handlers = {})\n\t    map[type] = (map[type] || noHandlers).concat(f)\n\t  }\n\t}\n\t\n\tfunction getHandlers(emitter, type) {\n\t  return emitter._handlers && emitter._handlers[type] || noHandlers\n\t}\n\t\n\tfunction off(emitter, type, f) {\n\t  if (emitter.removeEventListener) {\n\t    emitter.removeEventListener(type, f, false)\n\t  } else if (emitter.detachEvent) {\n\t    emitter.detachEvent(\"on\" + type, f)\n\t  } else {\n\t    var map = emitter._handlers, arr = map && map[type]\n\t    if (arr) {\n\t      var index = indexOf(arr, f)\n\t      if (index > -1)\n\t        { map[type] = arr.slice(0, index).concat(arr.slice(index + 1)) }\n\t    }\n\t  }\n\t}\n\t\n\tfunction signal(emitter, type /*, values...*/) {\n\t  var handlers = getHandlers(emitter, type)\n\t  if (!handlers.length) { return }\n\t  var args = Array.prototype.slice.call(arguments, 2)\n\t  for (var i = 0; i < handlers.length; ++i) { handlers[i].apply(null, args) }\n\t}\n\t\n\t// The DOM events that CodeMirror handles can be overridden by\n\t// registering a (non-DOM) handler on the editor for the event name,\n\t// and preventDefault-ing the event in that handler.\n\tfunction signalDOMEvent(cm, e, override) {\n\t  if (typeof e == \"string\")\n\t    { e = {type: e, preventDefault: function() { this.defaultPrevented = true }} }\n\t  signal(cm, override || e.type, cm, e)\n\t  return e_defaultPrevented(e) || e.codemirrorIgnore\n\t}\n\t\n\tfunction signalCursorActivity(cm) {\n\t  var arr = cm._handlers && cm._handlers.cursorActivity\n\t  if (!arr) { return }\n\t  var set = cm.curOp.cursorActivityHandlers || (cm.curOp.cursorActivityHandlers = [])\n\t  for (var i = 0; i < arr.length; ++i) { if (indexOf(set, arr[i]) == -1)\n\t    { set.push(arr[i]) } }\n\t}\n\t\n\tfunction hasHandler(emitter, type) {\n\t  return getHandlers(emitter, type).length > 0\n\t}\n\t\n\t// Add on and off methods to a constructor's prototype, to make\n\t// registering events on such objects more convenient.\n\tfunction eventMixin(ctor) {\n\t  ctor.prototype.on = function(type, f) {on(this, type, f)}\n\t  ctor.prototype.off = function(type, f) {off(this, type, f)}\n\t}\n\t\n\t// Due to the fact that we still support jurassic IE versions, some\n\t// compatibility wrappers are needed.\n\t\n\tfunction e_preventDefault(e) {\n\t  if (e.preventDefault) { e.preventDefault() }\n\t  else { e.returnValue = false }\n\t}\n\tfunction e_stopPropagation(e) {\n\t  if (e.stopPropagation) { e.stopPropagation() }\n\t  else { e.cancelBubble = true }\n\t}\n\tfunction e_defaultPrevented(e) {\n\t  return e.defaultPrevented != null ? e.defaultPrevented : e.returnValue == false\n\t}\n\tfunction e_stop(e) {e_preventDefault(e); e_stopPropagation(e)}\n\t\n\tfunction e_target(e) {return e.target || e.srcElement}\n\tfunction e_button(e) {\n\t  var b = e.which\n\t  if (b == null) {\n\t    if (e.button & 1) { b = 1 }\n\t    else if (e.button & 2) { b = 3 }\n\t    else if (e.button & 4) { b = 2 }\n\t  }\n\t  if (mac && e.ctrlKey && b == 1) { b = 3 }\n\t  return b\n\t}\n\t\n\t// Detect drag-and-drop\n\tvar dragAndDrop = function() {\n\t  // There is *some* kind of drag-and-drop support in IE6-8, but I\n\t  // couldn't get it to work yet.\n\t  if (ie && ie_version < 9) { return false }\n\t  var div = elt('div')\n\t  return \"draggable\" in div || \"dragDrop\" in div\n\t}()\n\t\n\tvar zwspSupported\n\tfunction zeroWidthElement(measure) {\n\t  if (zwspSupported == null) {\n\t    var test = elt(\"span\", \"\\u200b\")\n\t    removeChildrenAndAdd(measure, elt(\"span\", [test, document.createTextNode(\"x\")]))\n\t    if (measure.firstChild.offsetHeight != 0)\n\t      { zwspSupported = test.offsetWidth <= 1 && test.offsetHeight > 2 && !(ie && ie_version < 8) }\n\t  }\n\t  var node = zwspSupported ? elt(\"span\", \"\\u200b\") :\n\t    elt(\"span\", \"\\u00a0\", null, \"display: inline-block; width: 1px; margin-right: -1px\")\n\t  node.setAttribute(\"cm-text\", \"\")\n\t  return node\n\t}\n\t\n\t// Feature-detect IE's crummy client rect reporting for bidi text\n\tvar badBidiRects\n\tfunction hasBadBidiRects(measure) {\n\t  if (badBidiRects != null) { return badBidiRects }\n\t  var txt = removeChildrenAndAdd(measure, document.createTextNode(\"A\\u062eA\"))\n\t  var r0 = range(txt, 0, 1).getBoundingClientRect()\n\t  var r1 = range(txt, 1, 2).getBoundingClientRect()\n\t  removeChildren(measure)\n\t  if (!r0 || r0.left == r0.right) { return false } // Safari returns null in some cases (#2780)\n\t  return badBidiRects = (r1.right - r0.right < 3)\n\t}\n\t\n\t// See if \"\".split is the broken IE version, if so, provide an\n\t// alternative way to split lines.\n\tvar splitLinesAuto = \"\\n\\nb\".split(/\\n/).length != 3 ? function (string) {\n\t  var pos = 0, result = [], l = string.length\n\t  while (pos <= l) {\n\t    var nl = string.indexOf(\"\\n\", pos)\n\t    if (nl == -1) { nl = string.length }\n\t    var line = string.slice(pos, string.charAt(nl - 1) == \"\\r\" ? nl - 1 : nl)\n\t    var rt = line.indexOf(\"\\r\")\n\t    if (rt != -1) {\n\t      result.push(line.slice(0, rt))\n\t      pos += rt + 1\n\t    } else {\n\t      result.push(line)\n\t      pos = nl + 1\n\t    }\n\t  }\n\t  return result\n\t} : function (string) { return string.split(/\\r\\n?|\\n/); }\n\t\n\tvar hasSelection = window.getSelection ? function (te) {\n\t  try { return te.selectionStart != te.selectionEnd }\n\t  catch(e) { return false }\n\t} : function (te) {\n\t  var range\n\t  try {range = te.ownerDocument.selection.createRange()}\n\t  catch(e) {}\n\t  if (!range || range.parentElement() != te) { return false }\n\t  return range.compareEndPoints(\"StartToEnd\", range) != 0\n\t}\n\t\n\tvar hasCopyEvent = (function () {\n\t  var e = elt(\"div\")\n\t  if (\"oncopy\" in e) { return true }\n\t  e.setAttribute(\"oncopy\", \"return;\")\n\t  return typeof e.oncopy == \"function\"\n\t})()\n\t\n\tvar badZoomedRects = null\n\tfunction hasBadZoomedRects(measure) {\n\t  if (badZoomedRects != null) { return badZoomedRects }\n\t  var node = removeChildrenAndAdd(measure, elt(\"span\", \"x\"))\n\t  var normal = node.getBoundingClientRect()\n\t  var fromRange = range(node, 0, 1).getBoundingClientRect()\n\t  return badZoomedRects = Math.abs(normal.left - fromRange.left) > 1\n\t}\n\t\n\tvar modes = {};\n\tvar mimeModes = {};\n\t// Extra arguments are stored as the mode's dependencies, which is\n\t// used by (legacy) mechanisms like loadmode.js to automatically\n\t// load a mode. (Preferred mechanism is the require/define calls.)\n\tfunction defineMode(name, mode) {\n\t  if (arguments.length > 2)\n\t    { mode.dependencies = Array.prototype.slice.call(arguments, 2) }\n\t  modes[name] = mode\n\t}\n\t\n\tfunction defineMIME(mime, spec) {\n\t  mimeModes[mime] = spec\n\t}\n\t\n\t// Given a MIME type, a {name, ...options} config object, or a name\n\t// string, return a mode config object.\n\tfunction resolveMode(spec) {\n\t  if (typeof spec == \"string\" && mimeModes.hasOwnProperty(spec)) {\n\t    spec = mimeModes[spec]\n\t  } else if (spec && typeof spec.name == \"string\" && mimeModes.hasOwnProperty(spec.name)) {\n\t    var found = mimeModes[spec.name]\n\t    if (typeof found == \"string\") { found = {name: found} }\n\t    spec = createObj(found, spec)\n\t    spec.name = found.name\n\t  } else if (typeof spec == \"string\" && /^[\\w\\-]+\\/[\\w\\-]+\\+xml$/.test(spec)) {\n\t    return resolveMode(\"application/xml\")\n\t  } else if (typeof spec == \"string\" && /^[\\w\\-]+\\/[\\w\\-]+\\+json$/.test(spec)) {\n\t    return resolveMode(\"application/json\")\n\t  }\n\t  if (typeof spec == \"string\") { return {name: spec} }\n\t  else { return spec || {name: \"null\"} }\n\t}\n\t\n\t// Given a mode spec (anything that resolveMode accepts), find and\n\t// initialize an actual mode object.\n\tfunction getMode(options, spec) {\n\t  spec = resolveMode(spec)\n\t  var mfactory = modes[spec.name]\n\t  if (!mfactory) { return getMode(options, \"text/plain\") }\n\t  var modeObj = mfactory(options, spec)\n\t  if (modeExtensions.hasOwnProperty(spec.name)) {\n\t    var exts = modeExtensions[spec.name]\n\t    for (var prop in exts) {\n\t      if (!exts.hasOwnProperty(prop)) { continue }\n\t      if (modeObj.hasOwnProperty(prop)) { modeObj[\"_\" + prop] = modeObj[prop] }\n\t      modeObj[prop] = exts[prop]\n\t    }\n\t  }\n\t  modeObj.name = spec.name\n\t  if (spec.helperType) { modeObj.helperType = spec.helperType }\n\t  if (spec.modeProps) { for (var prop$1 in spec.modeProps)\n\t    { modeObj[prop$1] = spec.modeProps[prop$1] } }\n\t\n\t  return modeObj\n\t}\n\t\n\t// This can be used to attach properties to mode objects from\n\t// outside the actual mode definition.\n\tvar modeExtensions = {}\n\tfunction extendMode(mode, properties) {\n\t  var exts = modeExtensions.hasOwnProperty(mode) ? modeExtensions[mode] : (modeExtensions[mode] = {})\n\t  copyObj(properties, exts)\n\t}\n\t\n\tfunction copyState(mode, state) {\n\t  if (state === true) { return state }\n\t  if (mode.copyState) { return mode.copyState(state) }\n\t  var nstate = {}\n\t  for (var n in state) {\n\t    var val = state[n]\n\t    if (val instanceof Array) { val = val.concat([]) }\n\t    nstate[n] = val\n\t  }\n\t  return nstate\n\t}\n\t\n\t// Given a mode and a state (for that mode), find the inner mode and\n\t// state at the position that the state refers to.\n\tfunction innerMode(mode, state) {\n\t  var info\n\t  while (mode.innerMode) {\n\t    info = mode.innerMode(state)\n\t    if (!info || info.mode == mode) { break }\n\t    state = info.state\n\t    mode = info.mode\n\t  }\n\t  return info || {mode: mode, state: state}\n\t}\n\t\n\tfunction startState(mode, a1, a2) {\n\t  return mode.startState ? mode.startState(a1, a2) : true\n\t}\n\t\n\t// STRING STREAM\n\t\n\t// Fed to the mode parsers, provides helper functions to make\n\t// parsers more succinct.\n\t\n\tvar StringStream = function(string, tabSize) {\n\t  this.pos = this.start = 0\n\t  this.string = string\n\t  this.tabSize = tabSize || 8\n\t  this.lastColumnPos = this.lastColumnValue = 0\n\t  this.lineStart = 0\n\t};\n\t\n\tStringStream.prototype.eol = function () {return this.pos >= this.string.length};\n\tStringStream.prototype.sol = function () {return this.pos == this.lineStart};\n\tStringStream.prototype.peek = function () {return this.string.charAt(this.pos) || undefined};\n\tStringStream.prototype.next = function () {\n\t  if (this.pos < this.string.length)\n\t    { return this.string.charAt(this.pos++) }\n\t};\n\tStringStream.prototype.eat = function (match) {\n\t  var ch = this.string.charAt(this.pos)\n\t  var ok\n\t  if (typeof match == \"string\") { ok = ch == match }\n\t  else { ok = ch && (match.test ? match.test(ch) : match(ch)) }\n\t  if (ok) {++this.pos; return ch}\n\t};\n\tStringStream.prototype.eatWhile = function (match) {\n\t  var start = this.pos\n\t  while (this.eat(match)){}\n\t  return this.pos > start\n\t};\n\tStringStream.prototype.eatSpace = function () {\n\t    var this$1 = this;\n\t\n\t  var start = this.pos\n\t  while (/[\\s\\u00a0]/.test(this.string.charAt(this.pos))) { ++this$1.pos }\n\t  return this.pos > start\n\t};\n\tStringStream.prototype.skipToEnd = function () {this.pos = this.string.length};\n\tStringStream.prototype.skipTo = function (ch) {\n\t  var found = this.string.indexOf(ch, this.pos)\n\t  if (found > -1) {this.pos = found; return true}\n\t};\n\tStringStream.prototype.backUp = function (n) {this.pos -= n};\n\tStringStream.prototype.column = function () {\n\t  if (this.lastColumnPos < this.start) {\n\t    this.lastColumnValue = countColumn(this.string, this.start, this.tabSize, this.lastColumnPos, this.lastColumnValue)\n\t    this.lastColumnPos = this.start\n\t  }\n\t  return this.lastColumnValue - (this.lineStart ? countColumn(this.string, this.lineStart, this.tabSize) : 0)\n\t};\n\tStringStream.prototype.indentation = function () {\n\t  return countColumn(this.string, null, this.tabSize) -\n\t    (this.lineStart ? countColumn(this.string, this.lineStart, this.tabSize) : 0)\n\t};\n\tStringStream.prototype.match = function (pattern, consume, caseInsensitive) {\n\t  if (typeof pattern == \"string\") {\n\t    var cased = function (str) { return caseInsensitive ? str.toLowerCase() : str; }\n\t    var substr = this.string.substr(this.pos, pattern.length)\n\t    if (cased(substr) == cased(pattern)) {\n\t      if (consume !== false) { this.pos += pattern.length }\n\t      return true\n\t    }\n\t  } else {\n\t    var match = this.string.slice(this.pos).match(pattern)\n\t    if (match && match.index > 0) { return null }\n\t    if (match && consume !== false) { this.pos += match[0].length }\n\t    return match\n\t  }\n\t};\n\tStringStream.prototype.current = function (){return this.string.slice(this.start, this.pos)};\n\tStringStream.prototype.hideFirstChars = function (n, inner) {\n\t  this.lineStart += n\n\t  try { return inner() }\n\t  finally { this.lineStart -= n }\n\t};\n\t\n\t// Compute a style array (an array starting with a mode generation\n\t// -- for invalidation -- followed by pairs of end positions and\n\t// style strings), which is used to highlight the tokens on the\n\t// line.\n\tfunction highlightLine(cm, line, state, forceToEnd) {\n\t  // A styles array always starts with a number identifying the\n\t  // mode/overlays that it is based on (for easy invalidation).\n\t  var st = [cm.state.modeGen], lineClasses = {}\n\t  // Compute the base array of styles\n\t  runMode(cm, line.text, cm.doc.mode, state, function (end, style) { return st.push(end, style); },\n\t    lineClasses, forceToEnd)\n\t\n\t  // Run overlays, adjust style array.\n\t  var loop = function ( o ) {\n\t    var overlay = cm.state.overlays[o], i = 1, at = 0\n\t    runMode(cm, line.text, overlay.mode, true, function (end, style) {\n\t      var start = i\n\t      // Ensure there's a token end at the current position, and that i points at it\n\t      while (at < end) {\n\t        var i_end = st[i]\n\t        if (i_end > end)\n\t          { st.splice(i, 1, end, st[i+1], i_end) }\n\t        i += 2\n\t        at = Math.min(end, i_end)\n\t      }\n\t      if (!style) { return }\n\t      if (overlay.opaque) {\n\t        st.splice(start, i - start, end, \"overlay \" + style)\n\t        i = start + 2\n\t      } else {\n\t        for (; start < i; start += 2) {\n\t          var cur = st[start+1]\n\t          st[start+1] = (cur ? cur + \" \" : \"\") + \"overlay \" + style\n\t        }\n\t      }\n\t    }, lineClasses)\n\t  };\n\t\n\t  for (var o = 0; o < cm.state.overlays.length; ++o) loop( o );\n\t\n\t  return {styles: st, classes: lineClasses.bgClass || lineClasses.textClass ? lineClasses : null}\n\t}\n\t\n\tfunction getLineStyles(cm, line, updateFrontier) {\n\t  if (!line.styles || line.styles[0] != cm.state.modeGen) {\n\t    var state = getStateBefore(cm, lineNo(line))\n\t    var result = highlightLine(cm, line, line.text.length > cm.options.maxHighlightLength ? copyState(cm.doc.mode, state) : state)\n\t    line.stateAfter = state\n\t    line.styles = result.styles\n\t    if (result.classes) { line.styleClasses = result.classes }\n\t    else if (line.styleClasses) { line.styleClasses = null }\n\t    if (updateFrontier === cm.doc.frontier) { cm.doc.frontier++ }\n\t  }\n\t  return line.styles\n\t}\n\t\n\tfunction getStateBefore(cm, n, precise) {\n\t  var doc = cm.doc, display = cm.display\n\t  if (!doc.mode.startState) { return true }\n\t  var pos = findStartLine(cm, n, precise), state = pos > doc.first && getLine(doc, pos-1).stateAfter\n\t  if (!state) { state = startState(doc.mode) }\n\t  else { state = copyState(doc.mode, state) }\n\t  doc.iter(pos, n, function (line) {\n\t    processLine(cm, line.text, state)\n\t    var save = pos == n - 1 || pos % 5 == 0 || pos >= display.viewFrom && pos < display.viewTo\n\t    line.stateAfter = save ? copyState(doc.mode, state) : null\n\t    ++pos\n\t  })\n\t  if (precise) { doc.frontier = pos }\n\t  return state\n\t}\n\t\n\t// Lightweight form of highlight -- proceed over this line and\n\t// update state, but don't save a style array. Used for lines that\n\t// aren't currently visible.\n\tfunction processLine(cm, text, state, startAt) {\n\t  var mode = cm.doc.mode\n\t  var stream = new StringStream(text, cm.options.tabSize)\n\t  stream.start = stream.pos = startAt || 0\n\t  if (text == \"\") { callBlankLine(mode, state) }\n\t  while (!stream.eol()) {\n\t    readToken(mode, stream, state)\n\t    stream.start = stream.pos\n\t  }\n\t}\n\t\n\tfunction callBlankLine(mode, state) {\n\t  if (mode.blankLine) { return mode.blankLine(state) }\n\t  if (!mode.innerMode) { return }\n\t  var inner = innerMode(mode, state)\n\t  if (inner.mode.blankLine) { return inner.mode.blankLine(inner.state) }\n\t}\n\t\n\tfunction readToken(mode, stream, state, inner) {\n\t  for (var i = 0; i < 10; i++) {\n\t    if (inner) { inner[0] = innerMode(mode, state).mode }\n\t    var style = mode.token(stream, state)\n\t    if (stream.pos > stream.start) { return style }\n\t  }\n\t  throw new Error(\"Mode \" + mode.name + \" failed to advance stream.\")\n\t}\n\t\n\t// Utility for getTokenAt and getLineTokens\n\tfunction takeToken(cm, pos, precise, asArray) {\n\t  var getObj = function (copy) { return ({\n\t    start: stream.start, end: stream.pos,\n\t    string: stream.current(),\n\t    type: style || null,\n\t    state: copy ? copyState(doc.mode, state) : state\n\t  }); }\n\t\n\t  var doc = cm.doc, mode = doc.mode, style\n\t  pos = clipPos(doc, pos)\n\t  var line = getLine(doc, pos.line), state = getStateBefore(cm, pos.line, precise)\n\t  var stream = new StringStream(line.text, cm.options.tabSize), tokens\n\t  if (asArray) { tokens = [] }\n\t  while ((asArray || stream.pos < pos.ch) && !stream.eol()) {\n\t    stream.start = stream.pos\n\t    style = readToken(mode, stream, state)\n\t    if (asArray) { tokens.push(getObj(true)) }\n\t  }\n\t  return asArray ? tokens : getObj()\n\t}\n\t\n\tfunction extractLineClasses(type, output) {\n\t  if (type) { for (;;) {\n\t    var lineClass = type.match(/(?:^|\\s+)line-(background-)?(\\S+)/)\n\t    if (!lineClass) { break }\n\t    type = type.slice(0, lineClass.index) + type.slice(lineClass.index + lineClass[0].length)\n\t    var prop = lineClass[1] ? \"bgClass\" : \"textClass\"\n\t    if (output[prop] == null)\n\t      { output[prop] = lineClass[2] }\n\t    else if (!(new RegExp(\"(?:^|\\s)\" + lineClass[2] + \"(?:$|\\s)\")).test(output[prop]))\n\t      { output[prop] += \" \" + lineClass[2] }\n\t  } }\n\t  return type\n\t}\n\t\n\t// Run the given mode's parser over a line, calling f for each token.\n\tfunction runMode(cm, text, mode, state, f, lineClasses, forceToEnd) {\n\t  var flattenSpans = mode.flattenSpans\n\t  if (flattenSpans == null) { flattenSpans = cm.options.flattenSpans }\n\t  var curStart = 0, curStyle = null\n\t  var stream = new StringStream(text, cm.options.tabSize), style\n\t  var inner = cm.options.addModeClass && [null]\n\t  if (text == \"\") { extractLineClasses(callBlankLine(mode, state), lineClasses) }\n\t  while (!stream.eol()) {\n\t    if (stream.pos > cm.options.maxHighlightLength) {\n\t      flattenSpans = false\n\t      if (forceToEnd) { processLine(cm, text, state, stream.pos) }\n\t      stream.pos = text.length\n\t      style = null\n\t    } else {\n\t      style = extractLineClasses(readToken(mode, stream, state, inner), lineClasses)\n\t    }\n\t    if (inner) {\n\t      var mName = inner[0].name\n\t      if (mName) { style = \"m-\" + (style ? mName + \" \" + style : mName) }\n\t    }\n\t    if (!flattenSpans || curStyle != style) {\n\t      while (curStart < stream.start) {\n\t        curStart = Math.min(stream.start, curStart + 5000)\n\t        f(curStart, curStyle)\n\t      }\n\t      curStyle = style\n\t    }\n\t    stream.start = stream.pos\n\t  }\n\t  while (curStart < stream.pos) {\n\t    // Webkit seems to refuse to render text nodes longer than 57444\n\t    // characters, and returns inaccurate measurements in nodes\n\t    // starting around 5000 chars.\n\t    var pos = Math.min(stream.pos, curStart + 5000)\n\t    f(pos, curStyle)\n\t    curStart = pos\n\t  }\n\t}\n\t\n\t// Finds the line to start with when starting a parse. Tries to\n\t// find a line with a stateAfter, so that it can start with a\n\t// valid state. If that fails, it returns the line with the\n\t// smallest indentation, which tends to need the least context to\n\t// parse correctly.\n\tfunction findStartLine(cm, n, precise) {\n\t  var minindent, minline, doc = cm.doc\n\t  var lim = precise ? -1 : n - (cm.doc.mode.innerMode ? 1000 : 100)\n\t  for (var search = n; search > lim; --search) {\n\t    if (search <= doc.first) { return doc.first }\n\t    var line = getLine(doc, search - 1)\n\t    if (line.stateAfter && (!precise || search <= doc.frontier)) { return search }\n\t    var indented = countColumn(line.text, null, cm.options.tabSize)\n\t    if (minline == null || minindent > indented) {\n\t      minline = search - 1\n\t      minindent = indented\n\t    }\n\t  }\n\t  return minline\n\t}\n\t\n\t// LINE DATA STRUCTURE\n\t\n\t// Line objects. These hold state related to a line, including\n\t// highlighting info (the styles array).\n\tvar Line = function(text, markedSpans, estimateHeight) {\n\t  this.text = text\n\t  attachMarkedSpans(this, markedSpans)\n\t  this.height = estimateHeight ? estimateHeight(this) : 1\n\t};\n\t\n\tLine.prototype.lineNo = function () { return lineNo(this) };\n\teventMixin(Line)\n\t\n\t// Change the content (text, markers) of a line. Automatically\n\t// invalidates cached information and tries to re-estimate the\n\t// line's height.\n\tfunction updateLine(line, text, markedSpans, estimateHeight) {\n\t  line.text = text\n\t  if (line.stateAfter) { line.stateAfter = null }\n\t  if (line.styles) { line.styles = null }\n\t  if (line.order != null) { line.order = null }\n\t  detachMarkedSpans(line)\n\t  attachMarkedSpans(line, markedSpans)\n\t  var estHeight = estimateHeight ? estimateHeight(line) : 1\n\t  if (estHeight != line.height) { updateLineHeight(line, estHeight) }\n\t}\n\t\n\t// Detach a line from the document tree and its markers.\n\tfunction cleanUpLine(line) {\n\t  line.parent = null\n\t  detachMarkedSpans(line)\n\t}\n\t\n\t// Convert a style as returned by a mode (either null, or a string\n\t// containing one or more styles) to a CSS style. This is cached,\n\t// and also looks for line-wide styles.\n\tvar styleToClassCache = {};\n\tvar styleToClassCacheWithMode = {};\n\tfunction interpretTokenStyle(style, options) {\n\t  if (!style || /^\\s*$/.test(style)) { return null }\n\t  var cache = options.addModeClass ? styleToClassCacheWithMode : styleToClassCache\n\t  return cache[style] ||\n\t    (cache[style] = style.replace(/\\S+/g, \"cm-$&\"))\n\t}\n\t\n\t// Render the DOM representation of the text of a line. Also builds\n\t// up a 'line map', which points at the DOM nodes that represent\n\t// specific stretches of text, and is used by the measuring code.\n\t// The returned object contains the DOM node, this map, and\n\t// information about line-wide styles that were set by the mode.\n\tfunction buildLineContent(cm, lineView) {\n\t  // The padding-right forces the element to have a 'border', which\n\t  // is needed on Webkit to be able to get line-level bounding\n\t  // rectangles for it (in measureChar).\n\t  var content = elt(\"span\", null, null, webkit ? \"padding-right: .1px\" : null)\n\t  var builder = {pre: elt(\"pre\", [content], \"CodeMirror-line\"), content: content,\n\t                 col: 0, pos: 0, cm: cm,\n\t                 trailingSpace: false,\n\t                 splitSpaces: (ie || webkit) && cm.getOption(\"lineWrapping\")}\n\t  // hide from accessibility tree\n\t  content.setAttribute(\"role\", \"presentation\")\n\t  builder.pre.setAttribute(\"role\", \"presentation\")\n\t  lineView.measure = {}\n\t\n\t  // Iterate over the logical lines that make up this visual line.\n\t  for (var i = 0; i <= (lineView.rest ? lineView.rest.length : 0); i++) {\n\t    var line = i ? lineView.rest[i - 1] : lineView.line, order = (void 0)\n\t    builder.pos = 0\n\t    builder.addToken = buildToken\n\t    // Optionally wire in some hacks into the token-rendering\n\t    // algorithm, to deal with browser quirks.\n\t    if (hasBadBidiRects(cm.display.measure) && (order = getOrder(line)))\n\t      { builder.addToken = buildTokenBadBidi(builder.addToken, order) }\n\t    builder.map = []\n\t    var allowFrontierUpdate = lineView != cm.display.externalMeasured && lineNo(line)\n\t    insertLineContent(line, builder, getLineStyles(cm, line, allowFrontierUpdate))\n\t    if (line.styleClasses) {\n\t      if (line.styleClasses.bgClass)\n\t        { builder.bgClass = joinClasses(line.styleClasses.bgClass, builder.bgClass || \"\") }\n\t      if (line.styleClasses.textClass)\n\t        { builder.textClass = joinClasses(line.styleClasses.textClass, builder.textClass || \"\") }\n\t    }\n\t\n\t    // Ensure at least a single node is present, for measuring.\n\t    if (builder.map.length == 0)\n\t      { builder.map.push(0, 0, builder.content.appendChild(zeroWidthElement(cm.display.measure))) }\n\t\n\t    // Store the map and a cache object for the current logical line\n\t    if (i == 0) {\n\t      lineView.measure.map = builder.map\n\t      lineView.measure.cache = {}\n\t    } else {\n\t      ;(lineView.measure.maps || (lineView.measure.maps = [])).push(builder.map)\n\t      ;(lineView.measure.caches || (lineView.measure.caches = [])).push({})\n\t    }\n\t  }\n\t\n\t  // See issue #2901\n\t  if (webkit) {\n\t    var last = builder.content.lastChild\n\t    if (/\\bcm-tab\\b/.test(last.className) || (last.querySelector && last.querySelector(\".cm-tab\")))\n\t      { builder.content.className = \"cm-tab-wrap-hack\" }\n\t  }\n\t\n\t  signal(cm, \"renderLine\", cm, lineView.line, builder.pre)\n\t  if (builder.pre.className)\n\t    { builder.textClass = joinClasses(builder.pre.className, builder.textClass || \"\") }\n\t\n\t  return builder\n\t}\n\t\n\tfunction defaultSpecialCharPlaceholder(ch) {\n\t  var token = elt(\"span\", \"\\u2022\", \"cm-invalidchar\")\n\t  token.title = \"\\\\u\" + ch.charCodeAt(0).toString(16)\n\t  token.setAttribute(\"aria-label\", token.title)\n\t  return token\n\t}\n\t\n\t// Build up the DOM representation for a single token, and add it to\n\t// the line map. Takes care to render special characters separately.\n\tfunction buildToken(builder, text, style, startStyle, endStyle, title, css) {\n\t  if (!text) { return }\n\t  var displayText = builder.splitSpaces ? splitSpaces(text, builder.trailingSpace) : text\n\t  var special = builder.cm.state.specialChars, mustWrap = false\n\t  var content\n\t  if (!special.test(text)) {\n\t    builder.col += text.length\n\t    content = document.createTextNode(displayText)\n\t    builder.map.push(builder.pos, builder.pos + text.length, content)\n\t    if (ie && ie_version < 9) { mustWrap = true }\n\t    builder.pos += text.length\n\t  } else {\n\t    content = document.createDocumentFragment()\n\t    var pos = 0\n\t    while (true) {\n\t      special.lastIndex = pos\n\t      var m = special.exec(text)\n\t      var skipped = m ? m.index - pos : text.length - pos\n\t      if (skipped) {\n\t        var txt = document.createTextNode(displayText.slice(pos, pos + skipped))\n\t        if (ie && ie_version < 9) { content.appendChild(elt(\"span\", [txt])) }\n\t        else { content.appendChild(txt) }\n\t        builder.map.push(builder.pos, builder.pos + skipped, txt)\n\t        builder.col += skipped\n\t        builder.pos += skipped\n\t      }\n\t      if (!m) { break }\n\t      pos += skipped + 1\n\t      var txt$1 = (void 0)\n\t      if (m[0] == \"\\t\") {\n\t        var tabSize = builder.cm.options.tabSize, tabWidth = tabSize - builder.col % tabSize\n\t        txt$1 = content.appendChild(elt(\"span\", spaceStr(tabWidth), \"cm-tab\"))\n\t        txt$1.setAttribute(\"role\", \"presentation\")\n\t        txt$1.setAttribute(\"cm-text\", \"\\t\")\n\t        builder.col += tabWidth\n\t      } else if (m[0] == \"\\r\" || m[0] == \"\\n\") {\n\t        txt$1 = content.appendChild(elt(\"span\", m[0] == \"\\r\" ? \"\\u240d\" : \"\\u2424\", \"cm-invalidchar\"))\n\t        txt$1.setAttribute(\"cm-text\", m[0])\n\t        builder.col += 1\n\t      } else {\n\t        txt$1 = builder.cm.options.specialCharPlaceholder(m[0])\n\t        txt$1.setAttribute(\"cm-text\", m[0])\n\t        if (ie && ie_version < 9) { content.appendChild(elt(\"span\", [txt$1])) }\n\t        else { content.appendChild(txt$1) }\n\t        builder.col += 1\n\t      }\n\t      builder.map.push(builder.pos, builder.pos + 1, txt$1)\n\t      builder.pos++\n\t    }\n\t  }\n\t  builder.trailingSpace = displayText.charCodeAt(text.length - 1) == 32\n\t  if (style || startStyle || endStyle || mustWrap || css) {\n\t    var fullStyle = style || \"\"\n\t    if (startStyle) { fullStyle += startStyle }\n\t    if (endStyle) { fullStyle += endStyle }\n\t    var token = elt(\"span\", [content], fullStyle, css)\n\t    if (title) { token.title = title }\n\t    return builder.content.appendChild(token)\n\t  }\n\t  builder.content.appendChild(content)\n\t}\n\t\n\tfunction splitSpaces(text, trailingBefore) {\n\t  if (text.length > 1 && !/  /.test(text)) { return text }\n\t  var spaceBefore = trailingBefore, result = \"\"\n\t  for (var i = 0; i < text.length; i++) {\n\t    var ch = text.charAt(i)\n\t    if (ch == \" \" && spaceBefore && (i == text.length - 1 || text.charCodeAt(i + 1) == 32))\n\t      { ch = \"\\u00a0\" }\n\t    result += ch\n\t    spaceBefore = ch == \" \"\n\t  }\n\t  return result\n\t}\n\t\n\t// Work around nonsense dimensions being reported for stretches of\n\t// right-to-left text.\n\tfunction buildTokenBadBidi(inner, order) {\n\t  return function (builder, text, style, startStyle, endStyle, title, css) {\n\t    style = style ? style + \" cm-force-border\" : \"cm-force-border\"\n\t    var start = builder.pos, end = start + text.length\n\t    for (;;) {\n\t      // Find the part that overlaps with the start of this text\n\t      var part = (void 0)\n\t      for (var i = 0; i < order.length; i++) {\n\t        part = order[i]\n\t        if (part.to > start && part.from <= start) { break }\n\t      }\n\t      if (part.to >= end) { return inner(builder, text, style, startStyle, endStyle, title, css) }\n\t      inner(builder, text.slice(0, part.to - start), style, startStyle, null, title, css)\n\t      startStyle = null\n\t      text = text.slice(part.to - start)\n\t      start = part.to\n\t    }\n\t  }\n\t}\n\t\n\tfunction buildCollapsedSpan(builder, size, marker, ignoreWidget) {\n\t  var widget = !ignoreWidget && marker.widgetNode\n\t  if (widget) { builder.map.push(builder.pos, builder.pos + size, widget) }\n\t  if (!ignoreWidget && builder.cm.display.input.needsContentAttribute) {\n\t    if (!widget)\n\t      { widget = builder.content.appendChild(document.createElement(\"span\")) }\n\t    widget.setAttribute(\"cm-marker\", marker.id)\n\t  }\n\t  if (widget) {\n\t    builder.cm.display.input.setUneditable(widget)\n\t    builder.content.appendChild(widget)\n\t  }\n\t  builder.pos += size\n\t  builder.trailingSpace = false\n\t}\n\t\n\t// Outputs a number of spans to make up a line, taking highlighting\n\t// and marked text into account.\n\tfunction insertLineContent(line, builder, styles) {\n\t  var spans = line.markedSpans, allText = line.text, at = 0\n\t  if (!spans) {\n\t    for (var i$1 = 1; i$1 < styles.length; i$1+=2)\n\t      { builder.addToken(builder, allText.slice(at, at = styles[i$1]), interpretTokenStyle(styles[i$1+1], builder.cm.options)) }\n\t    return\n\t  }\n\t\n\t  var len = allText.length, pos = 0, i = 1, text = \"\", style, css\n\t  var nextChange = 0, spanStyle, spanEndStyle, spanStartStyle, title, collapsed\n\t  for (;;) {\n\t    if (nextChange == pos) { // Update current marker set\n\t      spanStyle = spanEndStyle = spanStartStyle = title = css = \"\"\n\t      collapsed = null; nextChange = Infinity\n\t      var foundBookmarks = [], endStyles = (void 0)\n\t      for (var j = 0; j < spans.length; ++j) {\n\t        var sp = spans[j], m = sp.marker\n\t        if (m.type == \"bookmark\" && sp.from == pos && m.widgetNode) {\n\t          foundBookmarks.push(m)\n\t        } else if (sp.from <= pos && (sp.to == null || sp.to > pos || m.collapsed && sp.to == pos && sp.from == pos)) {\n\t          if (sp.to != null && sp.to != pos && nextChange > sp.to) {\n\t            nextChange = sp.to\n\t            spanEndStyle = \"\"\n\t          }\n\t          if (m.className) { spanStyle += \" \" + m.className }\n\t          if (m.css) { css = (css ? css + \";\" : \"\") + m.css }\n\t          if (m.startStyle && sp.from == pos) { spanStartStyle += \" \" + m.startStyle }\n\t          if (m.endStyle && sp.to == nextChange) { (endStyles || (endStyles = [])).push(m.endStyle, sp.to) }\n\t          if (m.title && !title) { title = m.title }\n\t          if (m.collapsed && (!collapsed || compareCollapsedMarkers(collapsed.marker, m) < 0))\n\t            { collapsed = sp }\n\t        } else if (sp.from > pos && nextChange > sp.from) {\n\t          nextChange = sp.from\n\t        }\n\t      }\n\t      if (endStyles) { for (var j$1 = 0; j$1 < endStyles.length; j$1 += 2)\n\t        { if (endStyles[j$1 + 1] == nextChange) { spanEndStyle += \" \" + endStyles[j$1] } } }\n\t\n\t      if (!collapsed || collapsed.from == pos) { for (var j$2 = 0; j$2 < foundBookmarks.length; ++j$2)\n\t        { buildCollapsedSpan(builder, 0, foundBookmarks[j$2]) } }\n\t      if (collapsed && (collapsed.from || 0) == pos) {\n\t        buildCollapsedSpan(builder, (collapsed.to == null ? len + 1 : collapsed.to) - pos,\n\t                           collapsed.marker, collapsed.from == null)\n\t        if (collapsed.to == null) { return }\n\t        if (collapsed.to == pos) { collapsed = false }\n\t      }\n\t    }\n\t    if (pos >= len) { break }\n\t\n\t    var upto = Math.min(len, nextChange)\n\t    while (true) {\n\t      if (text) {\n\t        var end = pos + text.length\n\t        if (!collapsed) {\n\t          var tokenText = end > upto ? text.slice(0, upto - pos) : text\n\t          builder.addToken(builder, tokenText, style ? style + spanStyle : spanStyle,\n\t                           spanStartStyle, pos + tokenText.length == nextChange ? spanEndStyle : \"\", title, css)\n\t        }\n\t        if (end >= upto) {text = text.slice(upto - pos); pos = upto; break}\n\t        pos = end\n\t        spanStartStyle = \"\"\n\t      }\n\t      text = allText.slice(at, at = styles[i++])\n\t      style = interpretTokenStyle(styles[i++], builder.cm.options)\n\t    }\n\t  }\n\t}\n\t\n\t\n\t// These objects are used to represent the visible (currently drawn)\n\t// part of the document. A LineView may correspond to multiple\n\t// logical lines, if those are connected by collapsed ranges.\n\tfunction LineView(doc, line, lineN) {\n\t  // The starting line\n\t  this.line = line\n\t  // Continuing lines, if any\n\t  this.rest = visualLineContinued(line)\n\t  // Number of logical lines in this visual line\n\t  this.size = this.rest ? lineNo(lst(this.rest)) - lineN + 1 : 1\n\t  this.node = this.text = null\n\t  this.hidden = lineIsHidden(doc, line)\n\t}\n\t\n\t// Create a range of LineView objects for the given lines.\n\tfunction buildViewArray(cm, from, to) {\n\t  var array = [], nextPos\n\t  for (var pos = from; pos < to; pos = nextPos) {\n\t    var view = new LineView(cm.doc, getLine(cm.doc, pos), pos)\n\t    nextPos = pos + view.size\n\t    array.push(view)\n\t  }\n\t  return array\n\t}\n\t\n\tvar operationGroup = null\n\t\n\tfunction pushOperation(op) {\n\t  if (operationGroup) {\n\t    operationGroup.ops.push(op)\n\t  } else {\n\t    op.ownsGroup = operationGroup = {\n\t      ops: [op],\n\t      delayedCallbacks: []\n\t    }\n\t  }\n\t}\n\t\n\tfunction fireCallbacksForOps(group) {\n\t  // Calls delayed callbacks and cursorActivity handlers until no\n\t  // new ones appear\n\t  var callbacks = group.delayedCallbacks, i = 0\n\t  do {\n\t    for (; i < callbacks.length; i++)\n\t      { callbacks[i].call(null) }\n\t    for (var j = 0; j < group.ops.length; j++) {\n\t      var op = group.ops[j]\n\t      if (op.cursorActivityHandlers)\n\t        { while (op.cursorActivityCalled < op.cursorActivityHandlers.length)\n\t          { op.cursorActivityHandlers[op.cursorActivityCalled++].call(null, op.cm) } }\n\t    }\n\t  } while (i < callbacks.length)\n\t}\n\t\n\tfunction finishOperation(op, endCb) {\n\t  var group = op.ownsGroup\n\t  if (!group) { return }\n\t\n\t  try { fireCallbacksForOps(group) }\n\t  finally {\n\t    operationGroup = null\n\t    endCb(group)\n\t  }\n\t}\n\t\n\tvar orphanDelayedCallbacks = null\n\t\n\t// Often, we want to signal events at a point where we are in the\n\t// middle of some work, but don't want the handler to start calling\n\t// other methods on the editor, which might be in an inconsistent\n\t// state or simply not expect any other events to happen.\n\t// signalLater looks whether there are any handlers, and schedules\n\t// them to be executed when the last operation ends, or, if no\n\t// operation is active, when a timeout fires.\n\tfunction signalLater(emitter, type /*, values...*/) {\n\t  var arr = getHandlers(emitter, type)\n\t  if (!arr.length) { return }\n\t  var args = Array.prototype.slice.call(arguments, 2), list\n\t  if (operationGroup) {\n\t    list = operationGroup.delayedCallbacks\n\t  } else if (orphanDelayedCallbacks) {\n\t    list = orphanDelayedCallbacks\n\t  } else {\n\t    list = orphanDelayedCallbacks = []\n\t    setTimeout(fireOrphanDelayed, 0)\n\t  }\n\t  var loop = function ( i ) {\n\t    list.push(function () { return arr[i].apply(null, args); })\n\t  };\n\t\n\t  for (var i = 0; i < arr.length; ++i)\n\t    loop( i );\n\t}\n\t\n\tfunction fireOrphanDelayed() {\n\t  var delayed = orphanDelayedCallbacks\n\t  orphanDelayedCallbacks = null\n\t  for (var i = 0; i < delayed.length; ++i) { delayed[i]() }\n\t}\n\t\n\t// When an aspect of a line changes, a string is added to\n\t// lineView.changes. This updates the relevant part of the line's\n\t// DOM structure.\n\tfunction updateLineForChanges(cm, lineView, lineN, dims) {\n\t  for (var j = 0; j < lineView.changes.length; j++) {\n\t    var type = lineView.changes[j]\n\t    if (type == \"text\") { updateLineText(cm, lineView) }\n\t    else if (type == \"gutter\") { updateLineGutter(cm, lineView, lineN, dims) }\n\t    else if (type == \"class\") { updateLineClasses(lineView) }\n\t    else if (type == \"widget\") { updateLineWidgets(cm, lineView, dims) }\n\t  }\n\t  lineView.changes = null\n\t}\n\t\n\t// Lines with gutter elements, widgets or a background class need to\n\t// be wrapped, and have the extra elements added to the wrapper div\n\tfunction ensureLineWrapped(lineView) {\n\t  if (lineView.node == lineView.text) {\n\t    lineView.node = elt(\"div\", null, null, \"position: relative\")\n\t    if (lineView.text.parentNode)\n\t      { lineView.text.parentNode.replaceChild(lineView.node, lineView.text) }\n\t    lineView.node.appendChild(lineView.text)\n\t    if (ie && ie_version < 8) { lineView.node.style.zIndex = 2 }\n\t  }\n\t  return lineView.node\n\t}\n\t\n\tfunction updateLineBackground(lineView) {\n\t  var cls = lineView.bgClass ? lineView.bgClass + \" \" + (lineView.line.bgClass || \"\") : lineView.line.bgClass\n\t  if (cls) { cls += \" CodeMirror-linebackground\" }\n\t  if (lineView.background) {\n\t    if (cls) { lineView.background.className = cls }\n\t    else { lineView.background.parentNode.removeChild(lineView.background); lineView.background = null }\n\t  } else if (cls) {\n\t    var wrap = ensureLineWrapped(lineView)\n\t    lineView.background = wrap.insertBefore(elt(\"div\", null, cls), wrap.firstChild)\n\t  }\n\t}\n\t\n\t// Wrapper around buildLineContent which will reuse the structure\n\t// in display.externalMeasured when possible.\n\tfunction getLineContent(cm, lineView) {\n\t  var ext = cm.display.externalMeasured\n\t  if (ext && ext.line == lineView.line) {\n\t    cm.display.externalMeasured = null\n\t    lineView.measure = ext.measure\n\t    return ext.built\n\t  }\n\t  return buildLineContent(cm, lineView)\n\t}\n\t\n\t// Redraw the line's text. Interacts with the background and text\n\t// classes because the mode may output tokens that influence these\n\t// classes.\n\tfunction updateLineText(cm, lineView) {\n\t  var cls = lineView.text.className\n\t  var built = getLineContent(cm, lineView)\n\t  if (lineView.text == lineView.node) { lineView.node = built.pre }\n\t  lineView.text.parentNode.replaceChild(built.pre, lineView.text)\n\t  lineView.text = built.pre\n\t  if (built.bgClass != lineView.bgClass || built.textClass != lineView.textClass) {\n\t    lineView.bgClass = built.bgClass\n\t    lineView.textClass = built.textClass\n\t    updateLineClasses(lineView)\n\t  } else if (cls) {\n\t    lineView.text.className = cls\n\t  }\n\t}\n\t\n\tfunction updateLineClasses(lineView) {\n\t  updateLineBackground(lineView)\n\t  if (lineView.line.wrapClass)\n\t    { ensureLineWrapped(lineView).className = lineView.line.wrapClass }\n\t  else if (lineView.node != lineView.text)\n\t    { lineView.node.className = \"\" }\n\t  var textClass = lineView.textClass ? lineView.textClass + \" \" + (lineView.line.textClass || \"\") : lineView.line.textClass\n\t  lineView.text.className = textClass || \"\"\n\t}\n\t\n\tfunction updateLineGutter(cm, lineView, lineN, dims) {\n\t  if (lineView.gutter) {\n\t    lineView.node.removeChild(lineView.gutter)\n\t    lineView.gutter = null\n\t  }\n\t  if (lineView.gutterBackground) {\n\t    lineView.node.removeChild(lineView.gutterBackground)\n\t    lineView.gutterBackground = null\n\t  }\n\t  if (lineView.line.gutterClass) {\n\t    var wrap = ensureLineWrapped(lineView)\n\t    lineView.gutterBackground = elt(\"div\", null, \"CodeMirror-gutter-background \" + lineView.line.gutterClass,\n\t                                    (\"left: \" + (cm.options.fixedGutter ? dims.fixedPos : -dims.gutterTotalWidth) + \"px; width: \" + (dims.gutterTotalWidth) + \"px\"))\n\t    wrap.insertBefore(lineView.gutterBackground, lineView.text)\n\t  }\n\t  var markers = lineView.line.gutterMarkers\n\t  if (cm.options.lineNumbers || markers) {\n\t    var wrap$1 = ensureLineWrapped(lineView)\n\t    var gutterWrap = lineView.gutter = elt(\"div\", null, \"CodeMirror-gutter-wrapper\", (\"left: \" + (cm.options.fixedGutter ? dims.fixedPos : -dims.gutterTotalWidth) + \"px\"))\n\t    cm.display.input.setUneditable(gutterWrap)\n\t    wrap$1.insertBefore(gutterWrap, lineView.text)\n\t    if (lineView.line.gutterClass)\n\t      { gutterWrap.className += \" \" + lineView.line.gutterClass }\n\t    if (cm.options.lineNumbers && (!markers || !markers[\"CodeMirror-linenumbers\"]))\n\t      { lineView.lineNumber = gutterWrap.appendChild(\n\t        elt(\"div\", lineNumberFor(cm.options, lineN),\n\t            \"CodeMirror-linenumber CodeMirror-gutter-elt\",\n\t            (\"left: \" + (dims.gutterLeft[\"CodeMirror-linenumbers\"]) + \"px; width: \" + (cm.display.lineNumInnerWidth) + \"px\"))) }\n\t    if (markers) { for (var k = 0; k < cm.options.gutters.length; ++k) {\n\t      var id = cm.options.gutters[k], found = markers.hasOwnProperty(id) && markers[id]\n\t      if (found)\n\t        { gutterWrap.appendChild(elt(\"div\", [found], \"CodeMirror-gutter-elt\",\n\t                                   (\"left: \" + (dims.gutterLeft[id]) + \"px; width: \" + (dims.gutterWidth[id]) + \"px\"))) }\n\t    } }\n\t  }\n\t}\n\t\n\tfunction updateLineWidgets(cm, lineView, dims) {\n\t  if (lineView.alignable) { lineView.alignable = null }\n\t  for (var node = lineView.node.firstChild, next = (void 0); node; node = next) {\n\t    next = node.nextSibling\n\t    if (node.className == \"CodeMirror-linewidget\")\n\t      { lineView.node.removeChild(node) }\n\t  }\n\t  insertLineWidgets(cm, lineView, dims)\n\t}\n\t\n\t// Build a line's DOM representation from scratch\n\tfunction buildLineElement(cm, lineView, lineN, dims) {\n\t  var built = getLineContent(cm, lineView)\n\t  lineView.text = lineView.node = built.pre\n\t  if (built.bgClass) { lineView.bgClass = built.bgClass }\n\t  if (built.textClass) { lineView.textClass = built.textClass }\n\t\n\t  updateLineClasses(lineView)\n\t  updateLineGutter(cm, lineView, lineN, dims)\n\t  insertLineWidgets(cm, lineView, dims)\n\t  return lineView.node\n\t}\n\t\n\t// A lineView may contain multiple logical lines (when merged by\n\t// collapsed spans). The widgets for all of them need to be drawn.\n\tfunction insertLineWidgets(cm, lineView, dims) {\n\t  insertLineWidgetsFor(cm, lineView.line, lineView, dims, true)\n\t  if (lineView.rest) { for (var i = 0; i < lineView.rest.length; i++)\n\t    { insertLineWidgetsFor(cm, lineView.rest[i], lineView, dims, false) } }\n\t}\n\t\n\tfunction insertLineWidgetsFor(cm, line, lineView, dims, allowAbove) {\n\t  if (!line.widgets) { return }\n\t  var wrap = ensureLineWrapped(lineView)\n\t  for (var i = 0, ws = line.widgets; i < ws.length; ++i) {\n\t    var widget = ws[i], node = elt(\"div\", [widget.node], \"CodeMirror-linewidget\")\n\t    if (!widget.handleMouseEvents) { node.setAttribute(\"cm-ignore-events\", \"true\") }\n\t    positionLineWidget(widget, node, lineView, dims)\n\t    cm.display.input.setUneditable(node)\n\t    if (allowAbove && widget.above)\n\t      { wrap.insertBefore(node, lineView.gutter || lineView.text) }\n\t    else\n\t      { wrap.appendChild(node) }\n\t    signalLater(widget, \"redraw\")\n\t  }\n\t}\n\t\n\tfunction positionLineWidget(widget, node, lineView, dims) {\n\t  if (widget.noHScroll) {\n\t    ;(lineView.alignable || (lineView.alignable = [])).push(node)\n\t    var width = dims.wrapperWidth\n\t    node.style.left = dims.fixedPos + \"px\"\n\t    if (!widget.coverGutter) {\n\t      width -= dims.gutterTotalWidth\n\t      node.style.paddingLeft = dims.gutterTotalWidth + \"px\"\n\t    }\n\t    node.style.width = width + \"px\"\n\t  }\n\t  if (widget.coverGutter) {\n\t    node.style.zIndex = 5\n\t    node.style.position = \"relative\"\n\t    if (!widget.noHScroll) { node.style.marginLeft = -dims.gutterTotalWidth + \"px\" }\n\t  }\n\t}\n\t\n\tfunction widgetHeight(widget) {\n\t  if (widget.height != null) { return widget.height }\n\t  var cm = widget.doc.cm\n\t  if (!cm) { return 0 }\n\t  if (!contains(document.body, widget.node)) {\n\t    var parentStyle = \"position: relative;\"\n\t    if (widget.coverGutter)\n\t      { parentStyle += \"margin-left: -\" + cm.display.gutters.offsetWidth + \"px;\" }\n\t    if (widget.noHScroll)\n\t      { parentStyle += \"width: \" + cm.display.wrapper.clientWidth + \"px;\" }\n\t    removeChildrenAndAdd(cm.display.measure, elt(\"div\", [widget.node], null, parentStyle))\n\t  }\n\t  return widget.height = widget.node.parentNode.offsetHeight\n\t}\n\t\n\t// Return true when the given mouse event happened in a widget\n\tfunction eventInWidget(display, e) {\n\t  for (var n = e_target(e); n != display.wrapper; n = n.parentNode) {\n\t    if (!n || (n.nodeType == 1 && n.getAttribute(\"cm-ignore-events\") == \"true\") ||\n\t        (n.parentNode == display.sizer && n != display.mover))\n\t      { return true }\n\t  }\n\t}\n\t\n\t// POSITION MEASUREMENT\n\t\n\tfunction paddingTop(display) {return display.lineSpace.offsetTop}\n\tfunction paddingVert(display) {return display.mover.offsetHeight - display.lineSpace.offsetHeight}\n\tfunction paddingH(display) {\n\t  if (display.cachedPaddingH) { return display.cachedPaddingH }\n\t  var e = removeChildrenAndAdd(display.measure, elt(\"pre\", \"x\"))\n\t  var style = window.getComputedStyle ? window.getComputedStyle(e) : e.currentStyle\n\t  var data = {left: parseInt(style.paddingLeft), right: parseInt(style.paddingRight)}\n\t  if (!isNaN(data.left) && !isNaN(data.right)) { display.cachedPaddingH = data }\n\t  return data\n\t}\n\t\n\tfunction scrollGap(cm) { return scrollerGap - cm.display.nativeBarWidth }\n\tfunction displayWidth(cm) {\n\t  return cm.display.scroller.clientWidth - scrollGap(cm) - cm.display.barWidth\n\t}\n\tfunction displayHeight(cm) {\n\t  return cm.display.scroller.clientHeight - scrollGap(cm) - cm.display.barHeight\n\t}\n\t\n\t// Ensure the lineView.wrapping.heights array is populated. This is\n\t// an array of bottom offsets for the lines that make up a drawn\n\t// line. When lineWrapping is on, there might be more than one\n\t// height.\n\tfunction ensureLineHeights(cm, lineView, rect) {\n\t  var wrapping = cm.options.lineWrapping\n\t  var curWidth = wrapping && displayWidth(cm)\n\t  if (!lineView.measure.heights || wrapping && lineView.measure.width != curWidth) {\n\t    var heights = lineView.measure.heights = []\n\t    if (wrapping) {\n\t      lineView.measure.width = curWidth\n\t      var rects = lineView.text.firstChild.getClientRects()\n\t      for (var i = 0; i < rects.length - 1; i++) {\n\t        var cur = rects[i], next = rects[i + 1]\n\t        if (Math.abs(cur.bottom - next.bottom) > 2)\n\t          { heights.push((cur.bottom + next.top) / 2 - rect.top) }\n\t      }\n\t    }\n\t    heights.push(rect.bottom - rect.top)\n\t  }\n\t}\n\t\n\t// Find a line map (mapping character offsets to text nodes) and a\n\t// measurement cache for the given line number. (A line view might\n\t// contain multiple lines when collapsed ranges are present.)\n\tfunction mapFromLineView(lineView, line, lineN) {\n\t  if (lineView.line == line)\n\t    { return {map: lineView.measure.map, cache: lineView.measure.cache} }\n\t  for (var i = 0; i < lineView.rest.length; i++)\n\t    { if (lineView.rest[i] == line)\n\t      { return {map: lineView.measure.maps[i], cache: lineView.measure.caches[i]} } }\n\t  for (var i$1 = 0; i$1 < lineView.rest.length; i$1++)\n\t    { if (lineNo(lineView.rest[i$1]) > lineN)\n\t      { return {map: lineView.measure.maps[i$1], cache: lineView.measure.caches[i$1], before: true} } }\n\t}\n\t\n\t// Render a line into the hidden node display.externalMeasured. Used\n\t// when measurement is needed for a line that's not in the viewport.\n\tfunction updateExternalMeasurement(cm, line) {\n\t  line = visualLine(line)\n\t  var lineN = lineNo(line)\n\t  var view = cm.display.externalMeasured = new LineView(cm.doc, line, lineN)\n\t  view.lineN = lineN\n\t  var built = view.built = buildLineContent(cm, view)\n\t  view.text = built.pre\n\t  removeChildrenAndAdd(cm.display.lineMeasure, built.pre)\n\t  return view\n\t}\n\t\n\t// Get a {top, bottom, left, right} box (in line-local coordinates)\n\t// for a given character.\n\tfunction measureChar(cm, line, ch, bias) {\n\t  return measureCharPrepared(cm, prepareMeasureForLine(cm, line), ch, bias)\n\t}\n\t\n\t// Find a line view that corresponds to the given line number.\n\tfunction findViewForLine(cm, lineN) {\n\t  if (lineN >= cm.display.viewFrom && lineN < cm.display.viewTo)\n\t    { return cm.display.view[findViewIndex(cm, lineN)] }\n\t  var ext = cm.display.externalMeasured\n\t  if (ext && lineN >= ext.lineN && lineN < ext.lineN + ext.size)\n\t    { return ext }\n\t}\n\t\n\t// Measurement can be split in two steps, the set-up work that\n\t// applies to the whole line, and the measurement of the actual\n\t// character. Functions like coordsChar, that need to do a lot of\n\t// measurements in a row, can thus ensure that the set-up work is\n\t// only done once.\n\tfunction prepareMeasureForLine(cm, line) {\n\t  var lineN = lineNo(line)\n\t  var view = findViewForLine(cm, lineN)\n\t  if (view && !view.text) {\n\t    view = null\n\t  } else if (view && view.changes) {\n\t    updateLineForChanges(cm, view, lineN, getDimensions(cm))\n\t    cm.curOp.forceUpdate = true\n\t  }\n\t  if (!view)\n\t    { view = updateExternalMeasurement(cm, line) }\n\t\n\t  var info = mapFromLineView(view, line, lineN)\n\t  return {\n\t    line: line, view: view, rect: null,\n\t    map: info.map, cache: info.cache, before: info.before,\n\t    hasHeights: false\n\t  }\n\t}\n\t\n\t// Given a prepared measurement object, measures the position of an\n\t// actual character (or fetches it from the cache).\n\tfunction measureCharPrepared(cm, prepared, ch, bias, varHeight) {\n\t  if (prepared.before) { ch = -1 }\n\t  var key = ch + (bias || \"\"), found\n\t  if (prepared.cache.hasOwnProperty(key)) {\n\t    found = prepared.cache[key]\n\t  } else {\n\t    if (!prepared.rect)\n\t      { prepared.rect = prepared.view.text.getBoundingClientRect() }\n\t    if (!prepared.hasHeights) {\n\t      ensureLineHeights(cm, prepared.view, prepared.rect)\n\t      prepared.hasHeights = true\n\t    }\n\t    found = measureCharInner(cm, prepared, ch, bias)\n\t    if (!found.bogus) { prepared.cache[key] = found }\n\t  }\n\t  return {left: found.left, right: found.right,\n\t          top: varHeight ? found.rtop : found.top,\n\t          bottom: varHeight ? found.rbottom : found.bottom}\n\t}\n\t\n\tvar nullRect = {left: 0, right: 0, top: 0, bottom: 0}\n\t\n\tfunction nodeAndOffsetInLineMap(map, ch, bias) {\n\t  var node, start, end, collapse, mStart, mEnd\n\t  // First, search the line map for the text node corresponding to,\n\t  // or closest to, the target character.\n\t  for (var i = 0; i < map.length; i += 3) {\n\t    mStart = map[i]\n\t    mEnd = map[i + 1]\n\t    if (ch < mStart) {\n\t      start = 0; end = 1\n\t      collapse = \"left\"\n\t    } else if (ch < mEnd) {\n\t      start = ch - mStart\n\t      end = start + 1\n\t    } else if (i == map.length - 3 || ch == mEnd && map[i + 3] > ch) {\n\t      end = mEnd - mStart\n\t      start = end - 1\n\t      if (ch >= mEnd) { collapse = \"right\" }\n\t    }\n\t    if (start != null) {\n\t      node = map[i + 2]\n\t      if (mStart == mEnd && bias == (node.insertLeft ? \"left\" : \"right\"))\n\t        { collapse = bias }\n\t      if (bias == \"left\" && start == 0)\n\t        { while (i && map[i - 2] == map[i - 3] && map[i - 1].insertLeft) {\n\t          node = map[(i -= 3) + 2]\n\t          collapse = \"left\"\n\t        } }\n\t      if (bias == \"right\" && start == mEnd - mStart)\n\t        { while (i < map.length - 3 && map[i + 3] == map[i + 4] && !map[i + 5].insertLeft) {\n\t          node = map[(i += 3) + 2]\n\t          collapse = \"right\"\n\t        } }\n\t      break\n\t    }\n\t  }\n\t  return {node: node, start: start, end: end, collapse: collapse, coverStart: mStart, coverEnd: mEnd}\n\t}\n\t\n\tfunction getUsefulRect(rects, bias) {\n\t  var rect = nullRect\n\t  if (bias == \"left\") { for (var i = 0; i < rects.length; i++) {\n\t    if ((rect = rects[i]).left != rect.right) { break }\n\t  } } else { for (var i$1 = rects.length - 1; i$1 >= 0; i$1--) {\n\t    if ((rect = rects[i$1]).left != rect.right) { break }\n\t  } }\n\t  return rect\n\t}\n\t\n\tfunction measureCharInner(cm, prepared, ch, bias) {\n\t  var place = nodeAndOffsetInLineMap(prepared.map, ch, bias)\n\t  var node = place.node, start = place.start, end = place.end, collapse = place.collapse\n\t\n\t  var rect\n\t  if (node.nodeType == 3) { // If it is a text node, use a range to retrieve the coordinates.\n\t    for (var i$1 = 0; i$1 < 4; i$1++) { // Retry a maximum of 4 times when nonsense rectangles are returned\n\t      while (start && isExtendingChar(prepared.line.text.charAt(place.coverStart + start))) { --start }\n\t      while (place.coverStart + end < place.coverEnd && isExtendingChar(prepared.line.text.charAt(place.coverStart + end))) { ++end }\n\t      if (ie && ie_version < 9 && start == 0 && end == place.coverEnd - place.coverStart)\n\t        { rect = node.parentNode.getBoundingClientRect() }\n\t      else\n\t        { rect = getUsefulRect(range(node, start, end).getClientRects(), bias) }\n\t      if (rect.left || rect.right || start == 0) { break }\n\t      end = start\n\t      start = start - 1\n\t      collapse = \"right\"\n\t    }\n\t    if (ie && ie_version < 11) { rect = maybeUpdateRectForZooming(cm.display.measure, rect) }\n\t  } else { // If it is a widget, simply get the box for the whole widget.\n\t    if (start > 0) { collapse = bias = \"right\" }\n\t    var rects\n\t    if (cm.options.lineWrapping && (rects = node.getClientRects()).length > 1)\n\t      { rect = rects[bias == \"right\" ? rects.length - 1 : 0] }\n\t    else\n\t      { rect = node.getBoundingClientRect() }\n\t  }\n\t  if (ie && ie_version < 9 && !start && (!rect || !rect.left && !rect.right)) {\n\t    var rSpan = node.parentNode.getClientRects()[0]\n\t    if (rSpan)\n\t      { rect = {left: rSpan.left, right: rSpan.left + charWidth(cm.display), top: rSpan.top, bottom: rSpan.bottom} }\n\t    else\n\t      { rect = nullRect }\n\t  }\n\t\n\t  var rtop = rect.top - prepared.rect.top, rbot = rect.bottom - prepared.rect.top\n\t  var mid = (rtop + rbot) / 2\n\t  var heights = prepared.view.measure.heights\n\t  var i = 0\n\t  for (; i < heights.length - 1; i++)\n\t    { if (mid < heights[i]) { break } }\n\t  var top = i ? heights[i - 1] : 0, bot = heights[i]\n\t  var result = {left: (collapse == \"right\" ? rect.right : rect.left) - prepared.rect.left,\n\t                right: (collapse == \"left\" ? rect.left : rect.right) - prepared.rect.left,\n\t                top: top, bottom: bot}\n\t  if (!rect.left && !rect.right) { result.bogus = true }\n\t  if (!cm.options.singleCursorHeightPerLine) { result.rtop = rtop; result.rbottom = rbot }\n\t\n\t  return result\n\t}\n\t\n\t// Work around problem with bounding client rects on ranges being\n\t// returned incorrectly when zoomed on IE10 and below.\n\tfunction maybeUpdateRectForZooming(measure, rect) {\n\t  if (!window.screen || screen.logicalXDPI == null ||\n\t      screen.logicalXDPI == screen.deviceXDPI || !hasBadZoomedRects(measure))\n\t    { return rect }\n\t  var scaleX = screen.logicalXDPI / screen.deviceXDPI\n\t  var scaleY = screen.logicalYDPI / screen.deviceYDPI\n\t  return {left: rect.left * scaleX, right: rect.right * scaleX,\n\t          top: rect.top * scaleY, bottom: rect.bottom * scaleY}\n\t}\n\t\n\tfunction clearLineMeasurementCacheFor(lineView) {\n\t  if (lineView.measure) {\n\t    lineView.measure.cache = {}\n\t    lineView.measure.heights = null\n\t    if (lineView.rest) { for (var i = 0; i < lineView.rest.length; i++)\n\t      { lineView.measure.caches[i] = {} } }\n\t  }\n\t}\n\t\n\tfunction clearLineMeasurementCache(cm) {\n\t  cm.display.externalMeasure = null\n\t  removeChildren(cm.display.lineMeasure)\n\t  for (var i = 0; i < cm.display.view.length; i++)\n\t    { clearLineMeasurementCacheFor(cm.display.view[i]) }\n\t}\n\t\n\tfunction clearCaches(cm) {\n\t  clearLineMeasurementCache(cm)\n\t  cm.display.cachedCharWidth = cm.display.cachedTextHeight = cm.display.cachedPaddingH = null\n\t  if (!cm.options.lineWrapping) { cm.display.maxLineChanged = true }\n\t  cm.display.lineNumChars = null\n\t}\n\t\n\tfunction pageScrollX() { return window.pageXOffset || (document.documentElement || document.body).scrollLeft }\n\tfunction pageScrollY() { return window.pageYOffset || (document.documentElement || document.body).scrollTop }\n\t\n\t// Converts a {top, bottom, left, right} box from line-local\n\t// coordinates into another coordinate system. Context may be one of\n\t// \"line\", \"div\" (display.lineDiv), \"local\"./null (editor), \"window\",\n\t// or \"page\".\n\tfunction intoCoordSystem(cm, lineObj, rect, context, includeWidgets) {\n\t  if (!includeWidgets && lineObj.widgets) { for (var i = 0; i < lineObj.widgets.length; ++i) { if (lineObj.widgets[i].above) {\n\t    var size = widgetHeight(lineObj.widgets[i])\n\t    rect.top += size; rect.bottom += size\n\t  } } }\n\t  if (context == \"line\") { return rect }\n\t  if (!context) { context = \"local\" }\n\t  var yOff = heightAtLine(lineObj)\n\t  if (context == \"local\") { yOff += paddingTop(cm.display) }\n\t  else { yOff -= cm.display.viewOffset }\n\t  if (context == \"page\" || context == \"window\") {\n\t    var lOff = cm.display.lineSpace.getBoundingClientRect()\n\t    yOff += lOff.top + (context == \"window\" ? 0 : pageScrollY())\n\t    var xOff = lOff.left + (context == \"window\" ? 0 : pageScrollX())\n\t    rect.left += xOff; rect.right += xOff\n\t  }\n\t  rect.top += yOff; rect.bottom += yOff\n\t  return rect\n\t}\n\t\n\t// Coverts a box from \"div\" coords to another coordinate system.\n\t// Context may be \"window\", \"page\", \"div\", or \"local\"./null.\n\tfunction fromCoordSystem(cm, coords, context) {\n\t  if (context == \"div\") { return coords }\n\t  var left = coords.left, top = coords.top\n\t  // First move into \"page\" coordinate system\n\t  if (context == \"page\") {\n\t    left -= pageScrollX()\n\t    top -= pageScrollY()\n\t  } else if (context == \"local\" || !context) {\n\t    var localBox = cm.display.sizer.getBoundingClientRect()\n\t    left += localBox.left\n\t    top += localBox.top\n\t  }\n\t\n\t  var lineSpaceBox = cm.display.lineSpace.getBoundingClientRect()\n\t  return {left: left - lineSpaceBox.left, top: top - lineSpaceBox.top}\n\t}\n\t\n\tfunction charCoords(cm, pos, context, lineObj, bias) {\n\t  if (!lineObj) { lineObj = getLine(cm.doc, pos.line) }\n\t  return intoCoordSystem(cm, lineObj, measureChar(cm, lineObj, pos.ch, bias), context)\n\t}\n\t\n\t// Returns a box for a given cursor position, which may have an\n\t// 'other' property containing the position of the secondary cursor\n\t// on a bidi boundary.\n\t// A cursor Pos(line, char, \"before\") is on the same visual line as `char - 1`\n\t// and after `char - 1` in writing order of `char - 1`\n\t// A cursor Pos(line, char, \"after\") is on the same visual line as `char`\n\t// and before `char` in writing order of `char`\n\t// Examples (upper-case letters are RTL, lower-case are LTR):\n\t//     Pos(0, 1, ...)\n\t//     before   after\n\t// ab     a|b     a|b\n\t// aB     a|B     aB|\n\t// Ab     |Ab     A|b\n\t// AB     B|A     B|A\n\t// Every position after the last character on a line is considered to stick\n\t// to the last character on the line.\n\tfunction cursorCoords(cm, pos, context, lineObj, preparedMeasure, varHeight) {\n\t  lineObj = lineObj || getLine(cm.doc, pos.line)\n\t  if (!preparedMeasure) { preparedMeasure = prepareMeasureForLine(cm, lineObj) }\n\t  function get(ch, right) {\n\t    var m = measureCharPrepared(cm, preparedMeasure, ch, right ? \"right\" : \"left\", varHeight)\n\t    if (right) { m.left = m.right; } else { m.right = m.left }\n\t    return intoCoordSystem(cm, lineObj, m, context)\n\t  }\n\t  var order = getOrder(lineObj), ch = pos.ch, sticky = pos.sticky\n\t  if (ch >= lineObj.text.length) {\n\t    ch = lineObj.text.length\n\t    sticky = \"before\"\n\t  } else if (ch <= 0) {\n\t    ch = 0\n\t    sticky = \"after\"\n\t  }\n\t  if (!order) { return get(sticky == \"before\" ? ch - 1 : ch, sticky == \"before\") }\n\t\n\t  function getBidi(ch, partPos, invert) {\n\t    var part = order[partPos], right = (part.level % 2) != 0\n\t    return get(invert ? ch - 1 : ch, right != invert)\n\t  }\n\t  var partPos = getBidiPartAt(order, ch, sticky)\n\t  var other = bidiOther\n\t  var val = getBidi(ch, partPos, sticky == \"before\")\n\t  if (other != null) { val.other = getBidi(ch, other, sticky != \"before\") }\n\t  return val\n\t}\n\t\n\t// Used to cheaply estimate the coordinates for a position. Used for\n\t// intermediate scroll updates.\n\tfunction estimateCoords(cm, pos) {\n\t  var left = 0\n\t  pos = clipPos(cm.doc, pos)\n\t  if (!cm.options.lineWrapping) { left = charWidth(cm.display) * pos.ch }\n\t  var lineObj = getLine(cm.doc, pos.line)\n\t  var top = heightAtLine(lineObj) + paddingTop(cm.display)\n\t  return {left: left, right: left, top: top, bottom: top + lineObj.height}\n\t}\n\t\n\t// Positions returned by coordsChar contain some extra information.\n\t// xRel is the relative x position of the input coordinates compared\n\t// to the found position (so xRel > 0 means the coordinates are to\n\t// the right of the character position, for example). When outside\n\t// is true, that means the coordinates lie outside the line's\n\t// vertical range.\n\tfunction PosWithInfo(line, ch, sticky, outside, xRel) {\n\t  var pos = Pos(line, ch, sticky)\n\t  pos.xRel = xRel\n\t  if (outside) { pos.outside = true }\n\t  return pos\n\t}\n\t\n\t// Compute the character position closest to the given coordinates.\n\t// Input must be lineSpace-local (\"div\" coordinate system).\n\tfunction coordsChar(cm, x, y) {\n\t  var doc = cm.doc\n\t  y += cm.display.viewOffset\n\t  if (y < 0) { return PosWithInfo(doc.first, 0, null, true, -1) }\n\t  var lineN = lineAtHeight(doc, y), last = doc.first + doc.size - 1\n\t  if (lineN > last)\n\t    { return PosWithInfo(doc.first + doc.size - 1, getLine(doc, last).text.length, null, true, 1) }\n\t  if (x < 0) { x = 0 }\n\t\n\t  var lineObj = getLine(doc, lineN)\n\t  for (;;) {\n\t    var found = coordsCharInner(cm, lineObj, lineN, x, y)\n\t    var merged = collapsedSpanAtEnd(lineObj)\n\t    var mergedPos = merged && merged.find(0, true)\n\t    if (merged && (found.ch > mergedPos.from.ch || found.ch == mergedPos.from.ch && found.xRel > 0))\n\t      { lineN = lineNo(lineObj = mergedPos.to.line) }\n\t    else\n\t      { return found }\n\t  }\n\t}\n\t\n\tfunction wrappedLineExtent(cm, lineObj, preparedMeasure, y) {\n\t  var measure = function (ch) { return intoCoordSystem(cm, lineObj, measureCharPrepared(cm, preparedMeasure, ch), \"line\"); }\n\t  var end = lineObj.text.length\n\t  var begin = findFirst(function (ch) { return measure(ch - 1).bottom <= y; }, end, 0)\n\t  end = findFirst(function (ch) { return measure(ch).top > y; }, begin, end)\n\t  return {begin: begin, end: end}\n\t}\n\t\n\tfunction wrappedLineExtentChar(cm, lineObj, preparedMeasure, target) {\n\t  var targetTop = intoCoordSystem(cm, lineObj, measureCharPrepared(cm, preparedMeasure, target), \"line\").top\n\t  return wrappedLineExtent(cm, lineObj, preparedMeasure, targetTop)\n\t}\n\t\n\tfunction coordsCharInner(cm, lineObj, lineNo, x, y) {\n\t  y -= heightAtLine(lineObj)\n\t  var begin = 0, end = lineObj.text.length\n\t  var preparedMeasure = prepareMeasureForLine(cm, lineObj)\n\t  var pos\n\t  var order = getOrder(lineObj)\n\t  if (order) {\n\t    if (cm.options.lineWrapping) {\n\t      ;var assign;\n\t      ((assign = wrappedLineExtent(cm, lineObj, preparedMeasure, y), begin = assign.begin, end = assign.end, assign))\n\t    }\n\t    pos = new Pos(lineNo, begin)\n\t    var beginLeft = cursorCoords(cm, pos, \"line\", lineObj, preparedMeasure).left\n\t    var dir = beginLeft < x ? 1 : -1\n\t    var prevDiff, diff = beginLeft - x, prevPos\n\t    do {\n\t      prevDiff = diff\n\t      prevPos = pos\n\t      pos = moveVisually(cm, lineObj, pos, dir)\n\t      if (pos == null || pos.ch < begin || end <= (pos.sticky == \"before\" ? pos.ch - 1 : pos.ch)) {\n\t        pos = prevPos\n\t        break\n\t      }\n\t      diff = cursorCoords(cm, pos, \"line\", lineObj, preparedMeasure).left - x\n\t    } while ((dir < 0) != (diff < 0) && (Math.abs(diff) <= Math.abs(prevDiff)))\n\t    if (Math.abs(diff) > Math.abs(prevDiff)) {\n\t      if ((diff < 0) == (prevDiff < 0)) { throw new Error(\"Broke out of infinite loop in coordsCharInner\") }\n\t      pos = prevPos\n\t    }\n\t  } else {\n\t    var ch = findFirst(function (ch) {\n\t      var box = intoCoordSystem(cm, lineObj, measureCharPrepared(cm, preparedMeasure, ch), \"line\")\n\t      if (box.top > y) {\n\t        // For the cursor stickiness\n\t        end = Math.min(ch, end)\n\t        return true\n\t      }\n\t      else if (box.bottom <= y) { return false }\n\t      else if (box.left > x) { return true }\n\t      else if (box.right < x) { return false }\n\t      else { return (x - box.left < box.right - x) }\n\t    }, begin, end)\n\t    ch = skipExtendingChars(lineObj.text, ch, 1)\n\t    pos = new Pos(lineNo, ch, ch == end ? \"before\" : \"after\")\n\t  }\n\t  var coords = cursorCoords(cm, pos, \"line\", lineObj, preparedMeasure)\n\t  if (y < coords.top || coords.bottom < y) { pos.outside = true }\n\t  pos.xRel = x < coords.left ? -1 : (x > coords.right ? 1 : 0)\n\t  return pos\n\t}\n\t\n\tvar measureText\n\t// Compute the default text height.\n\tfunction textHeight(display) {\n\t  if (display.cachedTextHeight != null) { return display.cachedTextHeight }\n\t  if (measureText == null) {\n\t    measureText = elt(\"pre\")\n\t    // Measure a bunch of lines, for browsers that compute\n\t    // fractional heights.\n\t    for (var i = 0; i < 49; ++i) {\n\t      measureText.appendChild(document.createTextNode(\"x\"))\n\t      measureText.appendChild(elt(\"br\"))\n\t    }\n\t    measureText.appendChild(document.createTextNode(\"x\"))\n\t  }\n\t  removeChildrenAndAdd(display.measure, measureText)\n\t  var height = measureText.offsetHeight / 50\n\t  if (height > 3) { display.cachedTextHeight = height }\n\t  removeChildren(display.measure)\n\t  return height || 1\n\t}\n\t\n\t// Compute the default character width.\n\tfunction charWidth(display) {\n\t  if (display.cachedCharWidth != null) { return display.cachedCharWidth }\n\t  var anchor = elt(\"span\", \"xxxxxxxxxx\")\n\t  var pre = elt(\"pre\", [anchor])\n\t  removeChildrenAndAdd(display.measure, pre)\n\t  var rect = anchor.getBoundingClientRect(), width = (rect.right - rect.left) / 10\n\t  if (width > 2) { display.cachedCharWidth = width }\n\t  return width || 10\n\t}\n\t\n\t// Do a bulk-read of the DOM positions and sizes needed to draw the\n\t// view, so that we don't interleave reading and writing to the DOM.\n\tfunction getDimensions(cm) {\n\t  var d = cm.display, left = {}, width = {}\n\t  var gutterLeft = d.gutters.clientLeft\n\t  for (var n = d.gutters.firstChild, i = 0; n; n = n.nextSibling, ++i) {\n\t    left[cm.options.gutters[i]] = n.offsetLeft + n.clientLeft + gutterLeft\n\t    width[cm.options.gutters[i]] = n.clientWidth\n\t  }\n\t  return {fixedPos: compensateForHScroll(d),\n\t          gutterTotalWidth: d.gutters.offsetWidth,\n\t          gutterLeft: left,\n\t          gutterWidth: width,\n\t          wrapperWidth: d.wrapper.clientWidth}\n\t}\n\t\n\t// Computes display.scroller.scrollLeft + display.gutters.offsetWidth,\n\t// but using getBoundingClientRect to get a sub-pixel-accurate\n\t// result.\n\tfunction compensateForHScroll(display) {\n\t  return display.scroller.getBoundingClientRect().left - display.sizer.getBoundingClientRect().left\n\t}\n\t\n\t// Returns a function that estimates the height of a line, to use as\n\t// first approximation until the line becomes visible (and is thus\n\t// properly measurable).\n\tfunction estimateHeight(cm) {\n\t  var th = textHeight(cm.display), wrapping = cm.options.lineWrapping\n\t  var perLine = wrapping && Math.max(5, cm.display.scroller.clientWidth / charWidth(cm.display) - 3)\n\t  return function (line) {\n\t    if (lineIsHidden(cm.doc, line)) { return 0 }\n\t\n\t    var widgetsHeight = 0\n\t    if (line.widgets) { for (var i = 0; i < line.widgets.length; i++) {\n\t      if (line.widgets[i].height) { widgetsHeight += line.widgets[i].height }\n\t    } }\n\t\n\t    if (wrapping)\n\t      { return widgetsHeight + (Math.ceil(line.text.length / perLine) || 1) * th }\n\t    else\n\t      { return widgetsHeight + th }\n\t  }\n\t}\n\t\n\tfunction estimateLineHeights(cm) {\n\t  var doc = cm.doc, est = estimateHeight(cm)\n\t  doc.iter(function (line) {\n\t    var estHeight = est(line)\n\t    if (estHeight != line.height) { updateLineHeight(line, estHeight) }\n\t  })\n\t}\n\t\n\t// Given a mouse event, find the corresponding position. If liberal\n\t// is false, it checks whether a gutter or scrollbar was clicked,\n\t// and returns null if it was. forRect is used by rectangular\n\t// selections, and tries to estimate a character position even for\n\t// coordinates beyond the right of the text.\n\tfunction posFromMouse(cm, e, liberal, forRect) {\n\t  var display = cm.display\n\t  if (!liberal && e_target(e).getAttribute(\"cm-not-content\") == \"true\") { return null }\n\t\n\t  var x, y, space = display.lineSpace.getBoundingClientRect()\n\t  // Fails unpredictably on IE[67] when mouse is dragged around quickly.\n\t  try { x = e.clientX - space.left; y = e.clientY - space.top }\n\t  catch (e) { return null }\n\t  var coords = coordsChar(cm, x, y), line\n\t  if (forRect && coords.xRel == 1 && (line = getLine(cm.doc, coords.line).text).length == coords.ch) {\n\t    var colDiff = countColumn(line, line.length, cm.options.tabSize) - line.length\n\t    coords = Pos(coords.line, Math.max(0, Math.round((x - paddingH(cm.display).left) / charWidth(cm.display)) - colDiff))\n\t  }\n\t  return coords\n\t}\n\t\n\t// Find the view element corresponding to a given line. Return null\n\t// when the line isn't visible.\n\tfunction findViewIndex(cm, n) {\n\t  if (n >= cm.display.viewTo) { return null }\n\t  n -= cm.display.viewFrom\n\t  if (n < 0) { return null }\n\t  var view = cm.display.view\n\t  for (var i = 0; i < view.length; i++) {\n\t    n -= view[i].size\n\t    if (n < 0) { return i }\n\t  }\n\t}\n\t\n\tfunction updateSelection(cm) {\n\t  cm.display.input.showSelection(cm.display.input.prepareSelection())\n\t}\n\t\n\tfunction prepareSelection(cm, primary) {\n\t  var doc = cm.doc, result = {}\n\t  var curFragment = result.cursors = document.createDocumentFragment()\n\t  var selFragment = result.selection = document.createDocumentFragment()\n\t\n\t  for (var i = 0; i < doc.sel.ranges.length; i++) {\n\t    if (primary === false && i == doc.sel.primIndex) { continue }\n\t    var range = doc.sel.ranges[i]\n\t    if (range.from().line >= cm.display.viewTo || range.to().line < cm.display.viewFrom) { continue }\n\t    var collapsed = range.empty()\n\t    if (collapsed || cm.options.showCursorWhenSelecting)\n\t      { drawSelectionCursor(cm, range.head, curFragment) }\n\t    if (!collapsed)\n\t      { drawSelectionRange(cm, range, selFragment) }\n\t  }\n\t  return result\n\t}\n\t\n\t// Draws a cursor for the given range\n\tfunction drawSelectionCursor(cm, head, output) {\n\t  var pos = cursorCoords(cm, head, \"div\", null, null, !cm.options.singleCursorHeightPerLine)\n\t\n\t  var cursor = output.appendChild(elt(\"div\", \"\\u00a0\", \"CodeMirror-cursor\"))\n\t  cursor.style.left = pos.left + \"px\"\n\t  cursor.style.top = pos.top + \"px\"\n\t  cursor.style.height = Math.max(0, pos.bottom - pos.top) * cm.options.cursorHeight + \"px\"\n\t\n\t  if (pos.other) {\n\t    // Secondary cursor, shown when on a 'jump' in bi-directional text\n\t    var otherCursor = output.appendChild(elt(\"div\", \"\\u00a0\", \"CodeMirror-cursor CodeMirror-secondarycursor\"))\n\t    otherCursor.style.display = \"\"\n\t    otherCursor.style.left = pos.other.left + \"px\"\n\t    otherCursor.style.top = pos.other.top + \"px\"\n\t    otherCursor.style.height = (pos.other.bottom - pos.other.top) * .85 + \"px\"\n\t  }\n\t}\n\t\n\t// Draws the given range as a highlighted selection\n\tfunction drawSelectionRange(cm, range, output) {\n\t  var display = cm.display, doc = cm.doc\n\t  var fragment = document.createDocumentFragment()\n\t  var padding = paddingH(cm.display), leftSide = padding.left\n\t  var rightSide = Math.max(display.sizerWidth, displayWidth(cm) - display.sizer.offsetLeft) - padding.right\n\t\n\t  function add(left, top, width, bottom) {\n\t    if (top < 0) { top = 0 }\n\t    top = Math.round(top)\n\t    bottom = Math.round(bottom)\n\t    fragment.appendChild(elt(\"div\", null, \"CodeMirror-selected\", (\"position: absolute; left: \" + left + \"px;\\n                             top: \" + top + \"px; width: \" + (width == null ? rightSide - left : width) + \"px;\\n                             height: \" + (bottom - top) + \"px\")))\n\t  }\n\t\n\t  function drawForLine(line, fromArg, toArg) {\n\t    var lineObj = getLine(doc, line)\n\t    var lineLen = lineObj.text.length\n\t    var start, end\n\t    function coords(ch, bias) {\n\t      return charCoords(cm, Pos(line, ch), \"div\", lineObj, bias)\n\t    }\n\t\n\t    iterateBidiSections(getOrder(lineObj), fromArg || 0, toArg == null ? lineLen : toArg, function (from, to, dir) {\n\t      var leftPos = coords(from, \"left\"), rightPos, left, right\n\t      if (from == to) {\n\t        rightPos = leftPos\n\t        left = right = leftPos.left\n\t      } else {\n\t        rightPos = coords(to - 1, \"right\")\n\t        if (dir == \"rtl\") { var tmp = leftPos; leftPos = rightPos; rightPos = tmp }\n\t        left = leftPos.left\n\t        right = rightPos.right\n\t      }\n\t      if (fromArg == null && from == 0) { left = leftSide }\n\t      if (rightPos.top - leftPos.top > 3) { // Different lines, draw top part\n\t        add(left, leftPos.top, null, leftPos.bottom)\n\t        left = leftSide\n\t        if (leftPos.bottom < rightPos.top) { add(left, leftPos.bottom, null, rightPos.top) }\n\t      }\n\t      if (toArg == null && to == lineLen) { right = rightSide }\n\t      if (!start || leftPos.top < start.top || leftPos.top == start.top && leftPos.left < start.left)\n\t        { start = leftPos }\n\t      if (!end || rightPos.bottom > end.bottom || rightPos.bottom == end.bottom && rightPos.right > end.right)\n\t        { end = rightPos }\n\t      if (left < leftSide + 1) { left = leftSide }\n\t      add(left, rightPos.top, right - left, rightPos.bottom)\n\t    })\n\t    return {start: start, end: end}\n\t  }\n\t\n\t  var sFrom = range.from(), sTo = range.to()\n\t  if (sFrom.line == sTo.line) {\n\t    drawForLine(sFrom.line, sFrom.ch, sTo.ch)\n\t  } else {\n\t    var fromLine = getLine(doc, sFrom.line), toLine = getLine(doc, sTo.line)\n\t    var singleVLine = visualLine(fromLine) == visualLine(toLine)\n\t    var leftEnd = drawForLine(sFrom.line, sFrom.ch, singleVLine ? fromLine.text.length + 1 : null).end\n\t    var rightStart = drawForLine(sTo.line, singleVLine ? 0 : null, sTo.ch).start\n\t    if (singleVLine) {\n\t      if (leftEnd.top < rightStart.top - 2) {\n\t        add(leftEnd.right, leftEnd.top, null, leftEnd.bottom)\n\t        add(leftSide, rightStart.top, rightStart.left, rightStart.bottom)\n\t      } else {\n\t        add(leftEnd.right, leftEnd.top, rightStart.left - leftEnd.right, leftEnd.bottom)\n\t      }\n\t    }\n\t    if (leftEnd.bottom < rightStart.top)\n\t      { add(leftSide, leftEnd.bottom, null, rightStart.top) }\n\t  }\n\t\n\t  output.appendChild(fragment)\n\t}\n\t\n\t// Cursor-blinking\n\tfunction restartBlink(cm) {\n\t  if (!cm.state.focused) { return }\n\t  var display = cm.display\n\t  clearInterval(display.blinker)\n\t  var on = true\n\t  display.cursorDiv.style.visibility = \"\"\n\t  if (cm.options.cursorBlinkRate > 0)\n\t    { display.blinker = setInterval(function () { return display.cursorDiv.style.visibility = (on = !on) ? \"\" : \"hidden\"; },\n\t      cm.options.cursorBlinkRate) }\n\t  else if (cm.options.cursorBlinkRate < 0)\n\t    { display.cursorDiv.style.visibility = \"hidden\" }\n\t}\n\t\n\tfunction ensureFocus(cm) {\n\t  if (!cm.state.focused) { cm.display.input.focus(); onFocus(cm) }\n\t}\n\t\n\tfunction delayBlurEvent(cm) {\n\t  cm.state.delayingBlurEvent = true\n\t  setTimeout(function () { if (cm.state.delayingBlurEvent) {\n\t    cm.state.delayingBlurEvent = false\n\t    onBlur(cm)\n\t  } }, 100)\n\t}\n\t\n\tfunction onFocus(cm, e) {\n\t  if (cm.state.delayingBlurEvent) { cm.state.delayingBlurEvent = false }\n\t\n\t  if (cm.options.readOnly == \"nocursor\") { return }\n\t  if (!cm.state.focused) {\n\t    signal(cm, \"focus\", cm, e)\n\t    cm.state.focused = true\n\t    addClass(cm.display.wrapper, \"CodeMirror-focused\")\n\t    // This test prevents this from firing when a context\n\t    // menu is closed (since the input reset would kill the\n\t    // select-all detection hack)\n\t    if (!cm.curOp && cm.display.selForContextMenu != cm.doc.sel) {\n\t      cm.display.input.reset()\n\t      if (webkit) { setTimeout(function () { return cm.display.input.reset(true); }, 20) } // Issue #1730\n\t    }\n\t    cm.display.input.receivedFocus()\n\t  }\n\t  restartBlink(cm)\n\t}\n\tfunction onBlur(cm, e) {\n\t  if (cm.state.delayingBlurEvent) { return }\n\t\n\t  if (cm.state.focused) {\n\t    signal(cm, \"blur\", cm, e)\n\t    cm.state.focused = false\n\t    rmClass(cm.display.wrapper, \"CodeMirror-focused\")\n\t  }\n\t  clearInterval(cm.display.blinker)\n\t  setTimeout(function () { if (!cm.state.focused) { cm.display.shift = false } }, 150)\n\t}\n\t\n\t// Re-align line numbers and gutter marks to compensate for\n\t// horizontal scrolling.\n\tfunction alignHorizontally(cm) {\n\t  var display = cm.display, view = display.view\n\t  if (!display.alignWidgets && (!display.gutters.firstChild || !cm.options.fixedGutter)) { return }\n\t  var comp = compensateForHScroll(display) - display.scroller.scrollLeft + cm.doc.scrollLeft\n\t  var gutterW = display.gutters.offsetWidth, left = comp + \"px\"\n\t  for (var i = 0; i < view.length; i++) { if (!view[i].hidden) {\n\t    if (cm.options.fixedGutter) {\n\t      if (view[i].gutter)\n\t        { view[i].gutter.style.left = left }\n\t      if (view[i].gutterBackground)\n\t        { view[i].gutterBackground.style.left = left }\n\t    }\n\t    var align = view[i].alignable\n\t    if (align) { for (var j = 0; j < align.length; j++)\n\t      { align[j].style.left = left } }\n\t  } }\n\t  if (cm.options.fixedGutter)\n\t    { display.gutters.style.left = (comp + gutterW) + \"px\" }\n\t}\n\t\n\t// Used to ensure that the line number gutter is still the right\n\t// size for the current document size. Returns true when an update\n\t// is needed.\n\tfunction maybeUpdateLineNumberWidth(cm) {\n\t  if (!cm.options.lineNumbers) { return false }\n\t  var doc = cm.doc, last = lineNumberFor(cm.options, doc.first + doc.size - 1), display = cm.display\n\t  if (last.length != display.lineNumChars) {\n\t    var test = display.measure.appendChild(elt(\"div\", [elt(\"div\", last)],\n\t                                               \"CodeMirror-linenumber CodeMirror-gutter-elt\"))\n\t    var innerW = test.firstChild.offsetWidth, padding = test.offsetWidth - innerW\n\t    display.lineGutter.style.width = \"\"\n\t    display.lineNumInnerWidth = Math.max(innerW, display.lineGutter.offsetWidth - padding) + 1\n\t    display.lineNumWidth = display.lineNumInnerWidth + padding\n\t    display.lineNumChars = display.lineNumInnerWidth ? last.length : -1\n\t    display.lineGutter.style.width = display.lineNumWidth + \"px\"\n\t    updateGutterSpace(cm)\n\t    return true\n\t  }\n\t  return false\n\t}\n\t\n\t// Read the actual heights of the rendered lines, and update their\n\t// stored heights to match.\n\tfunction updateHeightsInViewport(cm) {\n\t  var display = cm.display\n\t  var prevBottom = display.lineDiv.offsetTop\n\t  for (var i = 0; i < display.view.length; i++) {\n\t    var cur = display.view[i], height = (void 0)\n\t    if (cur.hidden) { continue }\n\t    if (ie && ie_version < 8) {\n\t      var bot = cur.node.offsetTop + cur.node.offsetHeight\n\t      height = bot - prevBottom\n\t      prevBottom = bot\n\t    } else {\n\t      var box = cur.node.getBoundingClientRect()\n\t      height = box.bottom - box.top\n\t    }\n\t    var diff = cur.line.height - height\n\t    if (height < 2) { height = textHeight(display) }\n\t    if (diff > .001 || diff < -.001) {\n\t      updateLineHeight(cur.line, height)\n\t      updateWidgetHeight(cur.line)\n\t      if (cur.rest) { for (var j = 0; j < cur.rest.length; j++)\n\t        { updateWidgetHeight(cur.rest[j]) } }\n\t    }\n\t  }\n\t}\n\t\n\t// Read and store the height of line widgets associated with the\n\t// given line.\n\tfunction updateWidgetHeight(line) {\n\t  if (line.widgets) { for (var i = 0; i < line.widgets.length; ++i)\n\t    { line.widgets[i].height = line.widgets[i].node.parentNode.offsetHeight } }\n\t}\n\t\n\t// Compute the lines that are visible in a given viewport (defaults\n\t// the the current scroll position). viewport may contain top,\n\t// height, and ensure (see op.scrollToPos) properties.\n\tfunction visibleLines(display, doc, viewport) {\n\t  var top = viewport && viewport.top != null ? Math.max(0, viewport.top) : display.scroller.scrollTop\n\t  top = Math.floor(top - paddingTop(display))\n\t  var bottom = viewport && viewport.bottom != null ? viewport.bottom : top + display.wrapper.clientHeight\n\t\n\t  var from = lineAtHeight(doc, top), to = lineAtHeight(doc, bottom)\n\t  // Ensure is a {from: {line, ch}, to: {line, ch}} object, and\n\t  // forces those lines into the viewport (if possible).\n\t  if (viewport && viewport.ensure) {\n\t    var ensureFrom = viewport.ensure.from.line, ensureTo = viewport.ensure.to.line\n\t    if (ensureFrom < from) {\n\t      from = ensureFrom\n\t      to = lineAtHeight(doc, heightAtLine(getLine(doc, ensureFrom)) + display.wrapper.clientHeight)\n\t    } else if (Math.min(ensureTo, doc.lastLine()) >= to) {\n\t      from = lineAtHeight(doc, heightAtLine(getLine(doc, ensureTo)) - display.wrapper.clientHeight)\n\t      to = ensureTo\n\t    }\n\t  }\n\t  return {from: from, to: Math.max(to, from + 1)}\n\t}\n\t\n\t// Sync the scrollable area and scrollbars, ensure the viewport\n\t// covers the visible area.\n\tfunction setScrollTop(cm, val) {\n\t  if (Math.abs(cm.doc.scrollTop - val) < 2) { return }\n\t  cm.doc.scrollTop = val\n\t  if (!gecko) { updateDisplaySimple(cm, {top: val}) }\n\t  if (cm.display.scroller.scrollTop != val) { cm.display.scroller.scrollTop = val }\n\t  cm.display.scrollbars.setScrollTop(val)\n\t  if (gecko) { updateDisplaySimple(cm) }\n\t  startWorker(cm, 100)\n\t}\n\t// Sync scroller and scrollbar, ensure the gutter elements are\n\t// aligned.\n\tfunction setScrollLeft(cm, val, isScroller) {\n\t  if (isScroller ? val == cm.doc.scrollLeft : Math.abs(cm.doc.scrollLeft - val) < 2) { return }\n\t  val = Math.min(val, cm.display.scroller.scrollWidth - cm.display.scroller.clientWidth)\n\t  cm.doc.scrollLeft = val\n\t  alignHorizontally(cm)\n\t  if (cm.display.scroller.scrollLeft != val) { cm.display.scroller.scrollLeft = val }\n\t  cm.display.scrollbars.setScrollLeft(val)\n\t}\n\t\n\t// Since the delta values reported on mouse wheel events are\n\t// unstandardized between browsers and even browser versions, and\n\t// generally horribly unpredictable, this code starts by measuring\n\t// the scroll effect that the first few mouse wheel events have,\n\t// and, from that, detects the way it can convert deltas to pixel\n\t// offsets afterwards.\n\t//\n\t// The reason we want to know the amount a wheel event will scroll\n\t// is that it gives us a chance to update the display before the\n\t// actual scrolling happens, reducing flickering.\n\t\n\tvar wheelSamples = 0;\n\tvar wheelPixelsPerUnit = null;\n\t// Fill in a browser-detected starting value on browsers where we\n\t// know one. These don't have to be accurate -- the result of them\n\t// being wrong would just be a slight flicker on the first wheel\n\t// scroll (if it is large enough).\n\tif (ie) { wheelPixelsPerUnit = -.53 }\n\telse if (gecko) { wheelPixelsPerUnit = 15 }\n\telse if (chrome) { wheelPixelsPerUnit = -.7 }\n\telse if (safari) { wheelPixelsPerUnit = -1/3 }\n\t\n\tfunction wheelEventDelta(e) {\n\t  var dx = e.wheelDeltaX, dy = e.wheelDeltaY\n\t  if (dx == null && e.detail && e.axis == e.HORIZONTAL_AXIS) { dx = e.detail }\n\t  if (dy == null && e.detail && e.axis == e.VERTICAL_AXIS) { dy = e.detail }\n\t  else if (dy == null) { dy = e.wheelDelta }\n\t  return {x: dx, y: dy}\n\t}\n\tfunction wheelEventPixels(e) {\n\t  var delta = wheelEventDelta(e)\n\t  delta.x *= wheelPixelsPerUnit\n\t  delta.y *= wheelPixelsPerUnit\n\t  return delta\n\t}\n\t\n\tfunction onScrollWheel(cm, e) {\n\t  var delta = wheelEventDelta(e), dx = delta.x, dy = delta.y\n\t\n\t  var display = cm.display, scroll = display.scroller\n\t  // Quit if there's nothing to scroll here\n\t  var canScrollX = scroll.scrollWidth > scroll.clientWidth\n\t  var canScrollY = scroll.scrollHeight > scroll.clientHeight\n\t  if (!(dx && canScrollX || dy && canScrollY)) { return }\n\t\n\t  // Webkit browsers on OS X abort momentum scrolls when the target\n\t  // of the scroll event is removed from the scrollable element.\n\t  // This hack (see related code in patchDisplay) makes sure the\n\t  // element is kept around.\n\t  if (dy && mac && webkit) {\n\t    outer: for (var cur = e.target, view = display.view; cur != scroll; cur = cur.parentNode) {\n\t      for (var i = 0; i < view.length; i++) {\n\t        if (view[i].node == cur) {\n\t          cm.display.currentWheelTarget = cur\n\t          break outer\n\t        }\n\t      }\n\t    }\n\t  }\n\t\n\t  // On some browsers, horizontal scrolling will cause redraws to\n\t  // happen before the gutter has been realigned, causing it to\n\t  // wriggle around in a most unseemly way. When we have an\n\t  // estimated pixels/delta value, we just handle horizontal\n\t  // scrolling entirely here. It'll be slightly off from native, but\n\t  // better than glitching out.\n\t  if (dx && !gecko && !presto && wheelPixelsPerUnit != null) {\n\t    if (dy && canScrollY)\n\t      { setScrollTop(cm, Math.max(0, Math.min(scroll.scrollTop + dy * wheelPixelsPerUnit, scroll.scrollHeight - scroll.clientHeight))) }\n\t    setScrollLeft(cm, Math.max(0, Math.min(scroll.scrollLeft + dx * wheelPixelsPerUnit, scroll.scrollWidth - scroll.clientWidth)))\n\t    // Only prevent default scrolling if vertical scrolling is\n\t    // actually possible. Otherwise, it causes vertical scroll\n\t    // jitter on OSX trackpads when deltaX is small and deltaY\n\t    // is large (issue #3579)\n\t    if (!dy || (dy && canScrollY))\n\t      { e_preventDefault(e) }\n\t    display.wheelStartX = null // Abort measurement, if in progress\n\t    return\n\t  }\n\t\n\t  // 'Project' the visible viewport to cover the area that is being\n\t  // scrolled into view (if we know enough to estimate it).\n\t  if (dy && wheelPixelsPerUnit != null) {\n\t    var pixels = dy * wheelPixelsPerUnit\n\t    var top = cm.doc.scrollTop, bot = top + display.wrapper.clientHeight\n\t    if (pixels < 0) { top = Math.max(0, top + pixels - 50) }\n\t    else { bot = Math.min(cm.doc.height, bot + pixels + 50) }\n\t    updateDisplaySimple(cm, {top: top, bottom: bot})\n\t  }\n\t\n\t  if (wheelSamples < 20) {\n\t    if (display.wheelStartX == null) {\n\t      display.wheelStartX = scroll.scrollLeft; display.wheelStartY = scroll.scrollTop\n\t      display.wheelDX = dx; display.wheelDY = dy\n\t      setTimeout(function () {\n\t        if (display.wheelStartX == null) { return }\n\t        var movedX = scroll.scrollLeft - display.wheelStartX\n\t        var movedY = scroll.scrollTop - display.wheelStartY\n\t        var sample = (movedY && display.wheelDY && movedY / display.wheelDY) ||\n\t          (movedX && display.wheelDX && movedX / display.wheelDX)\n\t        display.wheelStartX = display.wheelStartY = null\n\t        if (!sample) { return }\n\t        wheelPixelsPerUnit = (wheelPixelsPerUnit * wheelSamples + sample) / (wheelSamples + 1)\n\t        ++wheelSamples\n\t      }, 200)\n\t    } else {\n\t      display.wheelDX += dx; display.wheelDY += dy\n\t    }\n\t  }\n\t}\n\t\n\t// SCROLLBARS\n\t\n\t// Prepare DOM reads needed to update the scrollbars. Done in one\n\t// shot to minimize update/measure roundtrips.\n\tfunction measureForScrollbars(cm) {\n\t  var d = cm.display, gutterW = d.gutters.offsetWidth\n\t  var docH = Math.round(cm.doc.height + paddingVert(cm.display))\n\t  return {\n\t    clientHeight: d.scroller.clientHeight,\n\t    viewHeight: d.wrapper.clientHeight,\n\t    scrollWidth: d.scroller.scrollWidth, clientWidth: d.scroller.clientWidth,\n\t    viewWidth: d.wrapper.clientWidth,\n\t    barLeft: cm.options.fixedGutter ? gutterW : 0,\n\t    docHeight: docH,\n\t    scrollHeight: docH + scrollGap(cm) + d.barHeight,\n\t    nativeBarWidth: d.nativeBarWidth,\n\t    gutterWidth: gutterW\n\t  }\n\t}\n\t\n\tvar NativeScrollbars = function(place, scroll, cm) {\n\t  this.cm = cm\n\t  var vert = this.vert = elt(\"div\", [elt(\"div\", null, null, \"min-width: 1px\")], \"CodeMirror-vscrollbar\")\n\t  var horiz = this.horiz = elt(\"div\", [elt(\"div\", null, null, \"height: 100%; min-height: 1px\")], \"CodeMirror-hscrollbar\")\n\t  place(vert); place(horiz)\n\t\n\t  on(vert, \"scroll\", function () {\n\t    if (vert.clientHeight) { scroll(vert.scrollTop, \"vertical\") }\n\t  })\n\t  on(horiz, \"scroll\", function () {\n\t    if (horiz.clientWidth) { scroll(horiz.scrollLeft, \"horizontal\") }\n\t  })\n\t\n\t  this.checkedZeroWidth = false\n\t  // Need to set a minimum width to see the scrollbar on IE7 (but must not set it on IE8).\n\t  if (ie && ie_version < 8) { this.horiz.style.minHeight = this.vert.style.minWidth = \"18px\" }\n\t};\n\t\n\tNativeScrollbars.prototype.update = function (measure) {\n\t  var needsH = measure.scrollWidth > measure.clientWidth + 1\n\t  var needsV = measure.scrollHeight > measure.clientHeight + 1\n\t  var sWidth = measure.nativeBarWidth\n\t\n\t  if (needsV) {\n\t    this.vert.style.display = \"block\"\n\t    this.vert.style.bottom = needsH ? sWidth + \"px\" : \"0\"\n\t    var totalHeight = measure.viewHeight - (needsH ? sWidth : 0)\n\t    // A bug in IE8 can cause this value to be negative, so guard it.\n\t    this.vert.firstChild.style.height =\n\t      Math.max(0, measure.scrollHeight - measure.clientHeight + totalHeight) + \"px\"\n\t  } else {\n\t    this.vert.style.display = \"\"\n\t    this.vert.firstChild.style.height = \"0\"\n\t  }\n\t\n\t  if (needsH) {\n\t    this.horiz.style.display = \"block\"\n\t    this.horiz.style.right = needsV ? sWidth + \"px\" : \"0\"\n\t    this.horiz.style.left = measure.barLeft + \"px\"\n\t    var totalWidth = measure.viewWidth - measure.barLeft - (needsV ? sWidth : 0)\n\t    this.horiz.firstChild.style.width =\n\t      Math.max(0, measure.scrollWidth - measure.clientWidth + totalWidth) + \"px\"\n\t  } else {\n\t    this.horiz.style.display = \"\"\n\t    this.horiz.firstChild.style.width = \"0\"\n\t  }\n\t\n\t  if (!this.checkedZeroWidth && measure.clientHeight > 0) {\n\t    if (sWidth == 0) { this.zeroWidthHack() }\n\t    this.checkedZeroWidth = true\n\t  }\n\t\n\t  return {right: needsV ? sWidth : 0, bottom: needsH ? sWidth : 0}\n\t};\n\t\n\tNativeScrollbars.prototype.setScrollLeft = function (pos) {\n\t  if (this.horiz.scrollLeft != pos) { this.horiz.scrollLeft = pos }\n\t  if (this.disableHoriz) { this.enableZeroWidthBar(this.horiz, this.disableHoriz) }\n\t};\n\t\n\tNativeScrollbars.prototype.setScrollTop = function (pos) {\n\t  if (this.vert.scrollTop != pos) { this.vert.scrollTop = pos }\n\t  if (this.disableVert) { this.enableZeroWidthBar(this.vert, this.disableVert) }\n\t};\n\t\n\tNativeScrollbars.prototype.zeroWidthHack = function () {\n\t  var w = mac && !mac_geMountainLion ? \"12px\" : \"18px\"\n\t  this.horiz.style.height = this.vert.style.width = w\n\t  this.horiz.style.pointerEvents = this.vert.style.pointerEvents = \"none\"\n\t  this.disableHoriz = new Delayed\n\t  this.disableVert = new Delayed\n\t};\n\t\n\tNativeScrollbars.prototype.enableZeroWidthBar = function (bar, delay) {\n\t  bar.style.pointerEvents = \"auto\"\n\t  function maybeDisable() {\n\t    // To find out whether the scrollbar is still visible, we\n\t    // check whether the element under the pixel in the bottom\n\t    // left corner of the scrollbar box is the scrollbar box\n\t    // itself (when the bar is still visible) or its filler child\n\t    // (when the bar is hidden). If it is still visible, we keep\n\t    // it enabled, if it's hidden, we disable pointer events.\n\t    var box = bar.getBoundingClientRect()\n\t    var elt = document.elementFromPoint(box.left + 1, box.bottom - 1)\n\t    if (elt != bar) { bar.style.pointerEvents = \"none\" }\n\t    else { delay.set(1000, maybeDisable) }\n\t  }\n\t  delay.set(1000, maybeDisable)\n\t};\n\t\n\tNativeScrollbars.prototype.clear = function () {\n\t  var parent = this.horiz.parentNode\n\t  parent.removeChild(this.horiz)\n\t  parent.removeChild(this.vert)\n\t};\n\t\n\tvar NullScrollbars = function () {};\n\t\n\tNullScrollbars.prototype.update = function () { return {bottom: 0, right: 0} };\n\tNullScrollbars.prototype.setScrollLeft = function () {};\n\tNullScrollbars.prototype.setScrollTop = function () {};\n\tNullScrollbars.prototype.clear = function () {};\n\t\n\tfunction updateScrollbars(cm, measure) {\n\t  if (!measure) { measure = measureForScrollbars(cm) }\n\t  var startWidth = cm.display.barWidth, startHeight = cm.display.barHeight\n\t  updateScrollbarsInner(cm, measure)\n\t  for (var i = 0; i < 4 && startWidth != cm.display.barWidth || startHeight != cm.display.barHeight; i++) {\n\t    if (startWidth != cm.display.barWidth && cm.options.lineWrapping)\n\t      { updateHeightsInViewport(cm) }\n\t    updateScrollbarsInner(cm, measureForScrollbars(cm))\n\t    startWidth = cm.display.barWidth; startHeight = cm.display.barHeight\n\t  }\n\t}\n\t\n\t// Re-synchronize the fake scrollbars with the actual size of the\n\t// content.\n\tfunction updateScrollbarsInner(cm, measure) {\n\t  var d = cm.display\n\t  var sizes = d.scrollbars.update(measure)\n\t\n\t  d.sizer.style.paddingRight = (d.barWidth = sizes.right) + \"px\"\n\t  d.sizer.style.paddingBottom = (d.barHeight = sizes.bottom) + \"px\"\n\t  d.heightForcer.style.borderBottom = sizes.bottom + \"px solid transparent\"\n\t\n\t  if (sizes.right && sizes.bottom) {\n\t    d.scrollbarFiller.style.display = \"block\"\n\t    d.scrollbarFiller.style.height = sizes.bottom + \"px\"\n\t    d.scrollbarFiller.style.width = sizes.right + \"px\"\n\t  } else { d.scrollbarFiller.style.display = \"\" }\n\t  if (sizes.bottom && cm.options.coverGutterNextToScrollbar && cm.options.fixedGutter) {\n\t    d.gutterFiller.style.display = \"block\"\n\t    d.gutterFiller.style.height = sizes.bottom + \"px\"\n\t    d.gutterFiller.style.width = measure.gutterWidth + \"px\"\n\t  } else { d.gutterFiller.style.display = \"\" }\n\t}\n\t\n\tvar scrollbarModel = {\"native\": NativeScrollbars, \"null\": NullScrollbars}\n\t\n\tfunction initScrollbars(cm) {\n\t  if (cm.display.scrollbars) {\n\t    cm.display.scrollbars.clear()\n\t    if (cm.display.scrollbars.addClass)\n\t      { rmClass(cm.display.wrapper, cm.display.scrollbars.addClass) }\n\t  }\n\t\n\t  cm.display.scrollbars = new scrollbarModel[cm.options.scrollbarStyle](function (node) {\n\t    cm.display.wrapper.insertBefore(node, cm.display.scrollbarFiller)\n\t    // Prevent clicks in the scrollbars from killing focus\n\t    on(node, \"mousedown\", function () {\n\t      if (cm.state.focused) { setTimeout(function () { return cm.display.input.focus(); }, 0) }\n\t    })\n\t    node.setAttribute(\"cm-not-content\", \"true\")\n\t  }, function (pos, axis) {\n\t    if (axis == \"horizontal\") { setScrollLeft(cm, pos) }\n\t    else { setScrollTop(cm, pos) }\n\t  }, cm)\n\t  if (cm.display.scrollbars.addClass)\n\t    { addClass(cm.display.wrapper, cm.display.scrollbars.addClass) }\n\t}\n\t\n\t// SCROLLING THINGS INTO VIEW\n\t\n\t// If an editor sits on the top or bottom of the window, partially\n\t// scrolled out of view, this ensures that the cursor is visible.\n\tfunction maybeScrollWindow(cm, coords) {\n\t  if (signalDOMEvent(cm, \"scrollCursorIntoView\")) { return }\n\t\n\t  var display = cm.display, box = display.sizer.getBoundingClientRect(), doScroll = null\n\t  if (coords.top + box.top < 0) { doScroll = true }\n\t  else if (coords.bottom + box.top > (window.innerHeight || document.documentElement.clientHeight)) { doScroll = false }\n\t  if (doScroll != null && !phantom) {\n\t    var scrollNode = elt(\"div\", \"\\u200b\", null, (\"position: absolute;\\n                         top: \" + (coords.top - display.viewOffset - paddingTop(cm.display)) + \"px;\\n                         height: \" + (coords.bottom - coords.top + scrollGap(cm) + display.barHeight) + \"px;\\n                         left: \" + (coords.left) + \"px; width: 2px;\"))\n\t    cm.display.lineSpace.appendChild(scrollNode)\n\t    scrollNode.scrollIntoView(doScroll)\n\t    cm.display.lineSpace.removeChild(scrollNode)\n\t  }\n\t}\n\t\n\t// Scroll a given position into view (immediately), verifying that\n\t// it actually became visible (as line heights are accurately\n\t// measured, the position of something may 'drift' during drawing).\n\tfunction scrollPosIntoView(cm, pos, end, margin) {\n\t  if (margin == null) { margin = 0 }\n\t  var coords\n\t  for (var limit = 0; limit < 5; limit++) {\n\t    var changed = false\n\t    coords = cursorCoords(cm, pos)\n\t    var endCoords = !end || end == pos ? coords : cursorCoords(cm, end)\n\t    var scrollPos = calculateScrollPos(cm, Math.min(coords.left, endCoords.left),\n\t                                       Math.min(coords.top, endCoords.top) - margin,\n\t                                       Math.max(coords.left, endCoords.left),\n\t                                       Math.max(coords.bottom, endCoords.bottom) + margin)\n\t    var startTop = cm.doc.scrollTop, startLeft = cm.doc.scrollLeft\n\t    if (scrollPos.scrollTop != null) {\n\t      setScrollTop(cm, scrollPos.scrollTop)\n\t      if (Math.abs(cm.doc.scrollTop - startTop) > 1) { changed = true }\n\t    }\n\t    if (scrollPos.scrollLeft != null) {\n\t      setScrollLeft(cm, scrollPos.scrollLeft)\n\t      if (Math.abs(cm.doc.scrollLeft - startLeft) > 1) { changed = true }\n\t    }\n\t    if (!changed) { break }\n\t  }\n\t  return coords\n\t}\n\t\n\t// Scroll a given set of coordinates into view (immediately).\n\tfunction scrollIntoView(cm, x1, y1, x2, y2) {\n\t  var scrollPos = calculateScrollPos(cm, x1, y1, x2, y2)\n\t  if (scrollPos.scrollTop != null) { setScrollTop(cm, scrollPos.scrollTop) }\n\t  if (scrollPos.scrollLeft != null) { setScrollLeft(cm, scrollPos.scrollLeft) }\n\t}\n\t\n\t// Calculate a new scroll position needed to scroll the given\n\t// rectangle into view. Returns an object with scrollTop and\n\t// scrollLeft properties. When these are undefined, the\n\t// vertical/horizontal position does not need to be adjusted.\n\tfunction calculateScrollPos(cm, x1, y1, x2, y2) {\n\t  var display = cm.display, snapMargin = textHeight(cm.display)\n\t  if (y1 < 0) { y1 = 0 }\n\t  var screentop = cm.curOp && cm.curOp.scrollTop != null ? cm.curOp.scrollTop : display.scroller.scrollTop\n\t  var screen = displayHeight(cm), result = {}\n\t  if (y2 - y1 > screen) { y2 = y1 + screen }\n\t  var docBottom = cm.doc.height + paddingVert(display)\n\t  var atTop = y1 < snapMargin, atBottom = y2 > docBottom - snapMargin\n\t  if (y1 < screentop) {\n\t    result.scrollTop = atTop ? 0 : y1\n\t  } else if (y2 > screentop + screen) {\n\t    var newTop = Math.min(y1, (atBottom ? docBottom : y2) - screen)\n\t    if (newTop != screentop) { result.scrollTop = newTop }\n\t  }\n\t\n\t  var screenleft = cm.curOp && cm.curOp.scrollLeft != null ? cm.curOp.scrollLeft : display.scroller.scrollLeft\n\t  var screenw = displayWidth(cm) - (cm.options.fixedGutter ? display.gutters.offsetWidth : 0)\n\t  var tooWide = x2 - x1 > screenw\n\t  if (tooWide) { x2 = x1 + screenw }\n\t  if (x1 < 10)\n\t    { result.scrollLeft = 0 }\n\t  else if (x1 < screenleft)\n\t    { result.scrollLeft = Math.max(0, x1 - (tooWide ? 0 : 10)) }\n\t  else if (x2 > screenw + screenleft - 3)\n\t    { result.scrollLeft = x2 + (tooWide ? 0 : 10) - screenw }\n\t  return result\n\t}\n\t\n\t// Store a relative adjustment to the scroll position in the current\n\t// operation (to be applied when the operation finishes).\n\tfunction addToScrollPos(cm, left, top) {\n\t  if (left != null || top != null) { resolveScrollToPos(cm) }\n\t  if (left != null)\n\t    { cm.curOp.scrollLeft = (cm.curOp.scrollLeft == null ? cm.doc.scrollLeft : cm.curOp.scrollLeft) + left }\n\t  if (top != null)\n\t    { cm.curOp.scrollTop = (cm.curOp.scrollTop == null ? cm.doc.scrollTop : cm.curOp.scrollTop) + top }\n\t}\n\t\n\t// Make sure that at the end of the operation the current cursor is\n\t// shown.\n\tfunction ensureCursorVisible(cm) {\n\t  resolveScrollToPos(cm)\n\t  var cur = cm.getCursor(), from = cur, to = cur\n\t  if (!cm.options.lineWrapping) {\n\t    from = cur.ch ? Pos(cur.line, cur.ch - 1) : cur\n\t    to = Pos(cur.line, cur.ch + 1)\n\t  }\n\t  cm.curOp.scrollToPos = {from: from, to: to, margin: cm.options.cursorScrollMargin, isCursor: true}\n\t}\n\t\n\t// When an operation has its scrollToPos property set, and another\n\t// scroll action is applied before the end of the operation, this\n\t// 'simulates' scrolling that position into view in a cheap way, so\n\t// that the effect of intermediate scroll commands is not ignored.\n\tfunction resolveScrollToPos(cm) {\n\t  var range = cm.curOp.scrollToPos\n\t  if (range) {\n\t    cm.curOp.scrollToPos = null\n\t    var from = estimateCoords(cm, range.from), to = estimateCoords(cm, range.to)\n\t    var sPos = calculateScrollPos(cm, Math.min(from.left, to.left),\n\t                                  Math.min(from.top, to.top) - range.margin,\n\t                                  Math.max(from.right, to.right),\n\t                                  Math.max(from.bottom, to.bottom) + range.margin)\n\t    cm.scrollTo(sPos.scrollLeft, sPos.scrollTop)\n\t  }\n\t}\n\t\n\t// Operations are used to wrap a series of changes to the editor\n\t// state in such a way that each change won't have to update the\n\t// cursor and display (which would be awkward, slow, and\n\t// error-prone). Instead, display updates are batched and then all\n\t// combined and executed at once.\n\t\n\tvar nextOpId = 0\n\t// Start a new operation.\n\tfunction startOperation(cm) {\n\t  cm.curOp = {\n\t    cm: cm,\n\t    viewChanged: false,      // Flag that indicates that lines might need to be redrawn\n\t    startHeight: cm.doc.height, // Used to detect need to update scrollbar\n\t    forceUpdate: false,      // Used to force a redraw\n\t    updateInput: null,       // Whether to reset the input textarea\n\t    typing: false,           // Whether this reset should be careful to leave existing text (for compositing)\n\t    changeObjs: null,        // Accumulated changes, for firing change events\n\t    cursorActivityHandlers: null, // Set of handlers to fire cursorActivity on\n\t    cursorActivityCalled: 0, // Tracks which cursorActivity handlers have been called already\n\t    selectionChanged: false, // Whether the selection needs to be redrawn\n\t    updateMaxLine: false,    // Set when the widest line needs to be determined anew\n\t    scrollLeft: null, scrollTop: null, // Intermediate scroll position, not pushed to DOM yet\n\t    scrollToPos: null,       // Used to scroll to a specific position\n\t    focus: false,\n\t    id: ++nextOpId           // Unique ID\n\t  }\n\t  pushOperation(cm.curOp)\n\t}\n\t\n\t// Finish an operation, updating the display and signalling delayed events\n\tfunction endOperation(cm) {\n\t  var op = cm.curOp\n\t  finishOperation(op, function (group) {\n\t    for (var i = 0; i < group.ops.length; i++)\n\t      { group.ops[i].cm.curOp = null }\n\t    endOperations(group)\n\t  })\n\t}\n\t\n\t// The DOM updates done when an operation finishes are batched so\n\t// that the minimum number of relayouts are required.\n\tfunction endOperations(group) {\n\t  var ops = group.ops\n\t  for (var i = 0; i < ops.length; i++) // Read DOM\n\t    { endOperation_R1(ops[i]) }\n\t  for (var i$1 = 0; i$1 < ops.length; i$1++) // Write DOM (maybe)\n\t    { endOperation_W1(ops[i$1]) }\n\t  for (var i$2 = 0; i$2 < ops.length; i$2++) // Read DOM\n\t    { endOperation_R2(ops[i$2]) }\n\t  for (var i$3 = 0; i$3 < ops.length; i$3++) // Write DOM (maybe)\n\t    { endOperation_W2(ops[i$3]) }\n\t  for (var i$4 = 0; i$4 < ops.length; i$4++) // Read DOM\n\t    { endOperation_finish(ops[i$4]) }\n\t}\n\t\n\tfunction endOperation_R1(op) {\n\t  var cm = op.cm, display = cm.display\n\t  maybeClipScrollbars(cm)\n\t  if (op.updateMaxLine) { findMaxLine(cm) }\n\t\n\t  op.mustUpdate = op.viewChanged || op.forceUpdate || op.scrollTop != null ||\n\t    op.scrollToPos && (op.scrollToPos.from.line < display.viewFrom ||\n\t                       op.scrollToPos.to.line >= display.viewTo) ||\n\t    display.maxLineChanged && cm.options.lineWrapping\n\t  op.update = op.mustUpdate &&\n\t    new DisplayUpdate(cm, op.mustUpdate && {top: op.scrollTop, ensure: op.scrollToPos}, op.forceUpdate)\n\t}\n\t\n\tfunction endOperation_W1(op) {\n\t  op.updatedDisplay = op.mustUpdate && updateDisplayIfNeeded(op.cm, op.update)\n\t}\n\t\n\tfunction endOperation_R2(op) {\n\t  var cm = op.cm, display = cm.display\n\t  if (op.updatedDisplay) { updateHeightsInViewport(cm) }\n\t\n\t  op.barMeasure = measureForScrollbars(cm)\n\t\n\t  // If the max line changed since it was last measured, measure it,\n\t  // and ensure the document's width matches it.\n\t  // updateDisplay_W2 will use these properties to do the actual resizing\n\t  if (display.maxLineChanged && !cm.options.lineWrapping) {\n\t    op.adjustWidthTo = measureChar(cm, display.maxLine, display.maxLine.text.length).left + 3\n\t    cm.display.sizerWidth = op.adjustWidthTo\n\t    op.barMeasure.scrollWidth =\n\t      Math.max(display.scroller.clientWidth, display.sizer.offsetLeft + op.adjustWidthTo + scrollGap(cm) + cm.display.barWidth)\n\t    op.maxScrollLeft = Math.max(0, display.sizer.offsetLeft + op.adjustWidthTo - displayWidth(cm))\n\t  }\n\t\n\t  if (op.updatedDisplay || op.selectionChanged)\n\t    { op.preparedSelection = display.input.prepareSelection(op.focus) }\n\t}\n\t\n\tfunction endOperation_W2(op) {\n\t  var cm = op.cm\n\t\n\t  if (op.adjustWidthTo != null) {\n\t    cm.display.sizer.style.minWidth = op.adjustWidthTo + \"px\"\n\t    if (op.maxScrollLeft < cm.doc.scrollLeft)\n\t      { setScrollLeft(cm, Math.min(cm.display.scroller.scrollLeft, op.maxScrollLeft), true) }\n\t    cm.display.maxLineChanged = false\n\t  }\n\t\n\t  var takeFocus = op.focus && op.focus == activeElt() && (!document.hasFocus || document.hasFocus())\n\t  if (op.preparedSelection)\n\t    { cm.display.input.showSelection(op.preparedSelection, takeFocus) }\n\t  if (op.updatedDisplay || op.startHeight != cm.doc.height)\n\t    { updateScrollbars(cm, op.barMeasure) }\n\t  if (op.updatedDisplay)\n\t    { setDocumentHeight(cm, op.barMeasure) }\n\t\n\t  if (op.selectionChanged) { restartBlink(cm) }\n\t\n\t  if (cm.state.focused && op.updateInput)\n\t    { cm.display.input.reset(op.typing) }\n\t  if (takeFocus) { ensureFocus(op.cm) }\n\t}\n\t\n\tfunction endOperation_finish(op) {\n\t  var cm = op.cm, display = cm.display, doc = cm.doc\n\t\n\t  if (op.updatedDisplay) { postUpdateDisplay(cm, op.update) }\n\t\n\t  // Abort mouse wheel delta measurement, when scrolling explicitly\n\t  if (display.wheelStartX != null && (op.scrollTop != null || op.scrollLeft != null || op.scrollToPos))\n\t    { display.wheelStartX = display.wheelStartY = null }\n\t\n\t  // Propagate the scroll position to the actual DOM scroller\n\t  if (op.scrollTop != null && (display.scroller.scrollTop != op.scrollTop || op.forceScroll)) {\n\t    doc.scrollTop = Math.max(0, Math.min(display.scroller.scrollHeight - display.scroller.clientHeight, op.scrollTop))\n\t    display.scrollbars.setScrollTop(doc.scrollTop)\n\t    display.scroller.scrollTop = doc.scrollTop\n\t  }\n\t  if (op.scrollLeft != null && (display.scroller.scrollLeft != op.scrollLeft || op.forceScroll)) {\n\t    doc.scrollLeft = Math.max(0, Math.min(display.scroller.scrollWidth - display.scroller.clientWidth, op.scrollLeft))\n\t    display.scrollbars.setScrollLeft(doc.scrollLeft)\n\t    display.scroller.scrollLeft = doc.scrollLeft\n\t    alignHorizontally(cm)\n\t  }\n\t  // If we need to scroll a specific position into view, do so.\n\t  if (op.scrollToPos) {\n\t    var coords = scrollPosIntoView(cm, clipPos(doc, op.scrollToPos.from),\n\t                                   clipPos(doc, op.scrollToPos.to), op.scrollToPos.margin)\n\t    if (op.scrollToPos.isCursor && cm.state.focused) { maybeScrollWindow(cm, coords) }\n\t  }\n\t\n\t  // Fire events for markers that are hidden/unidden by editing or\n\t  // undoing\n\t  var hidden = op.maybeHiddenMarkers, unhidden = op.maybeUnhiddenMarkers\n\t  if (hidden) { for (var i = 0; i < hidden.length; ++i)\n\t    { if (!hidden[i].lines.length) { signal(hidden[i], \"hide\") } } }\n\t  if (unhidden) { for (var i$1 = 0; i$1 < unhidden.length; ++i$1)\n\t    { if (unhidden[i$1].lines.length) { signal(unhidden[i$1], \"unhide\") } } }\n\t\n\t  if (display.wrapper.offsetHeight)\n\t    { doc.scrollTop = cm.display.scroller.scrollTop }\n\t\n\t  // Fire change events, and delayed event handlers\n\t  if (op.changeObjs)\n\t    { signal(cm, \"changes\", cm, op.changeObjs) }\n\t  if (op.update)\n\t    { op.update.finish() }\n\t}\n\t\n\t// Run the given function in an operation\n\tfunction runInOp(cm, f) {\n\t  if (cm.curOp) { return f() }\n\t  startOperation(cm)\n\t  try { return f() }\n\t  finally { endOperation(cm) }\n\t}\n\t// Wraps a function in an operation. Returns the wrapped function.\n\tfunction operation(cm, f) {\n\t  return function() {\n\t    if (cm.curOp) { return f.apply(cm, arguments) }\n\t    startOperation(cm)\n\t    try { return f.apply(cm, arguments) }\n\t    finally { endOperation(cm) }\n\t  }\n\t}\n\t// Used to add methods to editor and doc instances, wrapping them in\n\t// operations.\n\tfunction methodOp(f) {\n\t  return function() {\n\t    if (this.curOp) { return f.apply(this, arguments) }\n\t    startOperation(this)\n\t    try { return f.apply(this, arguments) }\n\t    finally { endOperation(this) }\n\t  }\n\t}\n\tfunction docMethodOp(f) {\n\t  return function() {\n\t    var cm = this.cm\n\t    if (!cm || cm.curOp) { return f.apply(this, arguments) }\n\t    startOperation(cm)\n\t    try { return f.apply(this, arguments) }\n\t    finally { endOperation(cm) }\n\t  }\n\t}\n\t\n\t// Updates the display.view data structure for a given change to the\n\t// document. From and to are in pre-change coordinates. Lendiff is\n\t// the amount of lines added or subtracted by the change. This is\n\t// used for changes that span multiple lines, or change the way\n\t// lines are divided into visual lines. regLineChange (below)\n\t// registers single-line changes.\n\tfunction regChange(cm, from, to, lendiff) {\n\t  if (from == null) { from = cm.doc.first }\n\t  if (to == null) { to = cm.doc.first + cm.doc.size }\n\t  if (!lendiff) { lendiff = 0 }\n\t\n\t  var display = cm.display\n\t  if (lendiff && to < display.viewTo &&\n\t      (display.updateLineNumbers == null || display.updateLineNumbers > from))\n\t    { display.updateLineNumbers = from }\n\t\n\t  cm.curOp.viewChanged = true\n\t\n\t  if (from >= display.viewTo) { // Change after\n\t    if (sawCollapsedSpans && visualLineNo(cm.doc, from) < display.viewTo)\n\t      { resetView(cm) }\n\t  } else if (to <= display.viewFrom) { // Change before\n\t    if (sawCollapsedSpans && visualLineEndNo(cm.doc, to + lendiff) > display.viewFrom) {\n\t      resetView(cm)\n\t    } else {\n\t      display.viewFrom += lendiff\n\t      display.viewTo += lendiff\n\t    }\n\t  } else if (from <= display.viewFrom && to >= display.viewTo) { // Full overlap\n\t    resetView(cm)\n\t  } else if (from <= display.viewFrom) { // Top overlap\n\t    var cut = viewCuttingPoint(cm, to, to + lendiff, 1)\n\t    if (cut) {\n\t      display.view = display.view.slice(cut.index)\n\t      display.viewFrom = cut.lineN\n\t      display.viewTo += lendiff\n\t    } else {\n\t      resetView(cm)\n\t    }\n\t  } else if (to >= display.viewTo) { // Bottom overlap\n\t    var cut$1 = viewCuttingPoint(cm, from, from, -1)\n\t    if (cut$1) {\n\t      display.view = display.view.slice(0, cut$1.index)\n\t      display.viewTo = cut$1.lineN\n\t    } else {\n\t      resetView(cm)\n\t    }\n\t  } else { // Gap in the middle\n\t    var cutTop = viewCuttingPoint(cm, from, from, -1)\n\t    var cutBot = viewCuttingPoint(cm, to, to + lendiff, 1)\n\t    if (cutTop && cutBot) {\n\t      display.view = display.view.slice(0, cutTop.index)\n\t        .concat(buildViewArray(cm, cutTop.lineN, cutBot.lineN))\n\t        .concat(display.view.slice(cutBot.index))\n\t      display.viewTo += lendiff\n\t    } else {\n\t      resetView(cm)\n\t    }\n\t  }\n\t\n\t  var ext = display.externalMeasured\n\t  if (ext) {\n\t    if (to < ext.lineN)\n\t      { ext.lineN += lendiff }\n\t    else if (from < ext.lineN + ext.size)\n\t      { display.externalMeasured = null }\n\t  }\n\t}\n\t\n\t// Register a change to a single line. Type must be one of \"text\",\n\t// \"gutter\", \"class\", \"widget\"\n\tfunction regLineChange(cm, line, type) {\n\t  cm.curOp.viewChanged = true\n\t  var display = cm.display, ext = cm.display.externalMeasured\n\t  if (ext && line >= ext.lineN && line < ext.lineN + ext.size)\n\t    { display.externalMeasured = null }\n\t\n\t  if (line < display.viewFrom || line >= display.viewTo) { return }\n\t  var lineView = display.view[findViewIndex(cm, line)]\n\t  if (lineView.node == null) { return }\n\t  var arr = lineView.changes || (lineView.changes = [])\n\t  if (indexOf(arr, type) == -1) { arr.push(type) }\n\t}\n\t\n\t// Clear the view.\n\tfunction resetView(cm) {\n\t  cm.display.viewFrom = cm.display.viewTo = cm.doc.first\n\t  cm.display.view = []\n\t  cm.display.viewOffset = 0\n\t}\n\t\n\tfunction viewCuttingPoint(cm, oldN, newN, dir) {\n\t  var index = findViewIndex(cm, oldN), diff, view = cm.display.view\n\t  if (!sawCollapsedSpans || newN == cm.doc.first + cm.doc.size)\n\t    { return {index: index, lineN: newN} }\n\t  var n = cm.display.viewFrom\n\t  for (var i = 0; i < index; i++)\n\t    { n += view[i].size }\n\t  if (n != oldN) {\n\t    if (dir > 0) {\n\t      if (index == view.length - 1) { return null }\n\t      diff = (n + view[index].size) - oldN\n\t      index++\n\t    } else {\n\t      diff = n - oldN\n\t    }\n\t    oldN += diff; newN += diff\n\t  }\n\t  while (visualLineNo(cm.doc, newN) != newN) {\n\t    if (index == (dir < 0 ? 0 : view.length - 1)) { return null }\n\t    newN += dir * view[index - (dir < 0 ? 1 : 0)].size\n\t    index += dir\n\t  }\n\t  return {index: index, lineN: newN}\n\t}\n\t\n\t// Force the view to cover a given range, adding empty view element\n\t// or clipping off existing ones as needed.\n\tfunction adjustView(cm, from, to) {\n\t  var display = cm.display, view = display.view\n\t  if (view.length == 0 || from >= display.viewTo || to <= display.viewFrom) {\n\t    display.view = buildViewArray(cm, from, to)\n\t    display.viewFrom = from\n\t  } else {\n\t    if (display.viewFrom > from)\n\t      { display.view = buildViewArray(cm, from, display.viewFrom).concat(display.view) }\n\t    else if (display.viewFrom < from)\n\t      { display.view = display.view.slice(findViewIndex(cm, from)) }\n\t    display.viewFrom = from\n\t    if (display.viewTo < to)\n\t      { display.view = display.view.concat(buildViewArray(cm, display.viewTo, to)) }\n\t    else if (display.viewTo > to)\n\t      { display.view = display.view.slice(0, findViewIndex(cm, to)) }\n\t  }\n\t  display.viewTo = to\n\t}\n\t\n\t// Count the number of lines in the view whose DOM representation is\n\t// out of date (or nonexistent).\n\tfunction countDirtyView(cm) {\n\t  var view = cm.display.view, dirty = 0\n\t  for (var i = 0; i < view.length; i++) {\n\t    var lineView = view[i]\n\t    if (!lineView.hidden && (!lineView.node || lineView.changes)) { ++dirty }\n\t  }\n\t  return dirty\n\t}\n\t\n\t// HIGHLIGHT WORKER\n\t\n\tfunction startWorker(cm, time) {\n\t  if (cm.doc.mode.startState && cm.doc.frontier < cm.display.viewTo)\n\t    { cm.state.highlight.set(time, bind(highlightWorker, cm)) }\n\t}\n\t\n\tfunction highlightWorker(cm) {\n\t  var doc = cm.doc\n\t  if (doc.frontier < doc.first) { doc.frontier = doc.first }\n\t  if (doc.frontier >= cm.display.viewTo) { return }\n\t  var end = +new Date + cm.options.workTime\n\t  var state = copyState(doc.mode, getStateBefore(cm, doc.frontier))\n\t  var changedLines = []\n\t\n\t  doc.iter(doc.frontier, Math.min(doc.first + doc.size, cm.display.viewTo + 500), function (line) {\n\t    if (doc.frontier >= cm.display.viewFrom) { // Visible\n\t      var oldStyles = line.styles, tooLong = line.text.length > cm.options.maxHighlightLength\n\t      var highlighted = highlightLine(cm, line, tooLong ? copyState(doc.mode, state) : state, true)\n\t      line.styles = highlighted.styles\n\t      var oldCls = line.styleClasses, newCls = highlighted.classes\n\t      if (newCls) { line.styleClasses = newCls }\n\t      else if (oldCls) { line.styleClasses = null }\n\t      var ischange = !oldStyles || oldStyles.length != line.styles.length ||\n\t        oldCls != newCls && (!oldCls || !newCls || oldCls.bgClass != newCls.bgClass || oldCls.textClass != newCls.textClass)\n\t      for (var i = 0; !ischange && i < oldStyles.length; ++i) { ischange = oldStyles[i] != line.styles[i] }\n\t      if (ischange) { changedLines.push(doc.frontier) }\n\t      line.stateAfter = tooLong ? state : copyState(doc.mode, state)\n\t    } else {\n\t      if (line.text.length <= cm.options.maxHighlightLength)\n\t        { processLine(cm, line.text, state) }\n\t      line.stateAfter = doc.frontier % 5 == 0 ? copyState(doc.mode, state) : null\n\t    }\n\t    ++doc.frontier\n\t    if (+new Date > end) {\n\t      startWorker(cm, cm.options.workDelay)\n\t      return true\n\t    }\n\t  })\n\t  if (changedLines.length) { runInOp(cm, function () {\n\t    for (var i = 0; i < changedLines.length; i++)\n\t      { regLineChange(cm, changedLines[i], \"text\") }\n\t  }) }\n\t}\n\t\n\t// DISPLAY DRAWING\n\t\n\tvar DisplayUpdate = function(cm, viewport, force) {\n\t  var display = cm.display\n\t\n\t  this.viewport = viewport\n\t  // Store some values that we'll need later (but don't want to force a relayout for)\n\t  this.visible = visibleLines(display, cm.doc, viewport)\n\t  this.editorIsHidden = !display.wrapper.offsetWidth\n\t  this.wrapperHeight = display.wrapper.clientHeight\n\t  this.wrapperWidth = display.wrapper.clientWidth\n\t  this.oldDisplayWidth = displayWidth(cm)\n\t  this.force = force\n\t  this.dims = getDimensions(cm)\n\t  this.events = []\n\t};\n\t\n\tDisplayUpdate.prototype.signal = function (emitter, type) {\n\t  if (hasHandler(emitter, type))\n\t    { this.events.push(arguments) }\n\t};\n\tDisplayUpdate.prototype.finish = function () {\n\t    var this$1 = this;\n\t\n\t  for (var i = 0; i < this.events.length; i++)\n\t    { signal.apply(null, this$1.events[i]) }\n\t};\n\t\n\tfunction maybeClipScrollbars(cm) {\n\t  var display = cm.display\n\t  if (!display.scrollbarsClipped && display.scroller.offsetWidth) {\n\t    display.nativeBarWidth = display.scroller.offsetWidth - display.scroller.clientWidth\n\t    display.heightForcer.style.height = scrollGap(cm) + \"px\"\n\t    display.sizer.style.marginBottom = -display.nativeBarWidth + \"px\"\n\t    display.sizer.style.borderRightWidth = scrollGap(cm) + \"px\"\n\t    display.scrollbarsClipped = true\n\t  }\n\t}\n\t\n\t// Does the actual updating of the line display. Bails out\n\t// (returning false) when there is nothing to be done and forced is\n\t// false.\n\tfunction updateDisplayIfNeeded(cm, update) {\n\t  var display = cm.display, doc = cm.doc\n\t\n\t  if (update.editorIsHidden) {\n\t    resetView(cm)\n\t    return false\n\t  }\n\t\n\t  // Bail out if the visible area is already rendered and nothing changed.\n\t  if (!update.force &&\n\t      update.visible.from >= display.viewFrom && update.visible.to <= display.viewTo &&\n\t      (display.updateLineNumbers == null || display.updateLineNumbers >= display.viewTo) &&\n\t      display.renderedView == display.view && countDirtyView(cm) == 0)\n\t    { return false }\n\t\n\t  if (maybeUpdateLineNumberWidth(cm)) {\n\t    resetView(cm)\n\t    update.dims = getDimensions(cm)\n\t  }\n\t\n\t  // Compute a suitable new viewport (from & to)\n\t  var end = doc.first + doc.size\n\t  var from = Math.max(update.visible.from - cm.options.viewportMargin, doc.first)\n\t  var to = Math.min(end, update.visible.to + cm.options.viewportMargin)\n\t  if (display.viewFrom < from && from - display.viewFrom < 20) { from = Math.max(doc.first, display.viewFrom) }\n\t  if (display.viewTo > to && display.viewTo - to < 20) { to = Math.min(end, display.viewTo) }\n\t  if (sawCollapsedSpans) {\n\t    from = visualLineNo(cm.doc, from)\n\t    to = visualLineEndNo(cm.doc, to)\n\t  }\n\t\n\t  var different = from != display.viewFrom || to != display.viewTo ||\n\t    display.lastWrapHeight != update.wrapperHeight || display.lastWrapWidth != update.wrapperWidth\n\t  adjustView(cm, from, to)\n\t\n\t  display.viewOffset = heightAtLine(getLine(cm.doc, display.viewFrom))\n\t  // Position the mover div to align with the current scroll position\n\t  cm.display.mover.style.top = display.viewOffset + \"px\"\n\t\n\t  var toUpdate = countDirtyView(cm)\n\t  if (!different && toUpdate == 0 && !update.force && display.renderedView == display.view &&\n\t      (display.updateLineNumbers == null || display.updateLineNumbers >= display.viewTo))\n\t    { return false }\n\t\n\t  // For big changes, we hide the enclosing element during the\n\t  // update, since that speeds up the operations on most browsers.\n\t  var focused = activeElt()\n\t  if (toUpdate > 4) { display.lineDiv.style.display = \"none\" }\n\t  patchDisplay(cm, display.updateLineNumbers, update.dims)\n\t  if (toUpdate > 4) { display.lineDiv.style.display = \"\" }\n\t  display.renderedView = display.view\n\t  // There might have been a widget with a focused element that got\n\t  // hidden or updated, if so re-focus it.\n\t  if (focused && activeElt() != focused && focused.offsetHeight) { focused.focus() }\n\t\n\t  // Prevent selection and cursors from interfering with the scroll\n\t  // width and height.\n\t  removeChildren(display.cursorDiv)\n\t  removeChildren(display.selectionDiv)\n\t  display.gutters.style.height = display.sizer.style.minHeight = 0\n\t\n\t  if (different) {\n\t    display.lastWrapHeight = update.wrapperHeight\n\t    display.lastWrapWidth = update.wrapperWidth\n\t    startWorker(cm, 400)\n\t  }\n\t\n\t  display.updateLineNumbers = null\n\t\n\t  return true\n\t}\n\t\n\tfunction postUpdateDisplay(cm, update) {\n\t  var viewport = update.viewport\n\t\n\t  for (var first = true;; first = false) {\n\t    if (!first || !cm.options.lineWrapping || update.oldDisplayWidth == displayWidth(cm)) {\n\t      // Clip forced viewport to actual scrollable area.\n\t      if (viewport && viewport.top != null)\n\t        { viewport = {top: Math.min(cm.doc.height + paddingVert(cm.display) - displayHeight(cm), viewport.top)} }\n\t      // Updated line heights might result in the drawn area not\n\t      // actually covering the viewport. Keep looping until it does.\n\t      update.visible = visibleLines(cm.display, cm.doc, viewport)\n\t      if (update.visible.from >= cm.display.viewFrom && update.visible.to <= cm.display.viewTo)\n\t        { break }\n\t    }\n\t    if (!updateDisplayIfNeeded(cm, update)) { break }\n\t    updateHeightsInViewport(cm)\n\t    var barMeasure = measureForScrollbars(cm)\n\t    updateSelection(cm)\n\t    updateScrollbars(cm, barMeasure)\n\t    setDocumentHeight(cm, barMeasure)\n\t  }\n\t\n\t  update.signal(cm, \"update\", cm)\n\t  if (cm.display.viewFrom != cm.display.reportedViewFrom || cm.display.viewTo != cm.display.reportedViewTo) {\n\t    update.signal(cm, \"viewportChange\", cm, cm.display.viewFrom, cm.display.viewTo)\n\t    cm.display.reportedViewFrom = cm.display.viewFrom; cm.display.reportedViewTo = cm.display.viewTo\n\t  }\n\t}\n\t\n\tfunction updateDisplaySimple(cm, viewport) {\n\t  var update = new DisplayUpdate(cm, viewport)\n\t  if (updateDisplayIfNeeded(cm, update)) {\n\t    updateHeightsInViewport(cm)\n\t    postUpdateDisplay(cm, update)\n\t    var barMeasure = measureForScrollbars(cm)\n\t    updateSelection(cm)\n\t    updateScrollbars(cm, barMeasure)\n\t    setDocumentHeight(cm, barMeasure)\n\t    update.finish()\n\t  }\n\t}\n\t\n\t// Sync the actual display DOM structure with display.view, removing\n\t// nodes for lines that are no longer in view, and creating the ones\n\t// that are not there yet, and updating the ones that are out of\n\t// date.\n\tfunction patchDisplay(cm, updateNumbersFrom, dims) {\n\t  var display = cm.display, lineNumbers = cm.options.lineNumbers\n\t  var container = display.lineDiv, cur = container.firstChild\n\t\n\t  function rm(node) {\n\t    var next = node.nextSibling\n\t    // Works around a throw-scroll bug in OS X Webkit\n\t    if (webkit && mac && cm.display.currentWheelTarget == node)\n\t      { node.style.display = \"none\" }\n\t    else\n\t      { node.parentNode.removeChild(node) }\n\t    return next\n\t  }\n\t\n\t  var view = display.view, lineN = display.viewFrom\n\t  // Loop over the elements in the view, syncing cur (the DOM nodes\n\t  // in display.lineDiv) with the view as we go.\n\t  for (var i = 0; i < view.length; i++) {\n\t    var lineView = view[i]\n\t    if (lineView.hidden) {\n\t    } else if (!lineView.node || lineView.node.parentNode != container) { // Not drawn yet\n\t      var node = buildLineElement(cm, lineView, lineN, dims)\n\t      container.insertBefore(node, cur)\n\t    } else { // Already drawn\n\t      while (cur != lineView.node) { cur = rm(cur) }\n\t      var updateNumber = lineNumbers && updateNumbersFrom != null &&\n\t        updateNumbersFrom <= lineN && lineView.lineNumber\n\t      if (lineView.changes) {\n\t        if (indexOf(lineView.changes, \"gutter\") > -1) { updateNumber = false }\n\t        updateLineForChanges(cm, lineView, lineN, dims)\n\t      }\n\t      if (updateNumber) {\n\t        removeChildren(lineView.lineNumber)\n\t        lineView.lineNumber.appendChild(document.createTextNode(lineNumberFor(cm.options, lineN)))\n\t      }\n\t      cur = lineView.node.nextSibling\n\t    }\n\t    lineN += lineView.size\n\t  }\n\t  while (cur) { cur = rm(cur) }\n\t}\n\t\n\tfunction updateGutterSpace(cm) {\n\t  var width = cm.display.gutters.offsetWidth\n\t  cm.display.sizer.style.marginLeft = width + \"px\"\n\t}\n\t\n\tfunction setDocumentHeight(cm, measure) {\n\t  cm.display.sizer.style.minHeight = measure.docHeight + \"px\"\n\t  cm.display.heightForcer.style.top = measure.docHeight + \"px\"\n\t  cm.display.gutters.style.height = (measure.docHeight + cm.display.barHeight + scrollGap(cm)) + \"px\"\n\t}\n\t\n\t// Rebuild the gutter elements, ensure the margin to the left of the\n\t// code matches their width.\n\tfunction updateGutters(cm) {\n\t  var gutters = cm.display.gutters, specs = cm.options.gutters\n\t  removeChildren(gutters)\n\t  var i = 0\n\t  for (; i < specs.length; ++i) {\n\t    var gutterClass = specs[i]\n\t    var gElt = gutters.appendChild(elt(\"div\", null, \"CodeMirror-gutter \" + gutterClass))\n\t    if (gutterClass == \"CodeMirror-linenumbers\") {\n\t      cm.display.lineGutter = gElt\n\t      gElt.style.width = (cm.display.lineNumWidth || 1) + \"px\"\n\t    }\n\t  }\n\t  gutters.style.display = i ? \"\" : \"none\"\n\t  updateGutterSpace(cm)\n\t}\n\t\n\t// Make sure the gutters options contains the element\n\t// \"CodeMirror-linenumbers\" when the lineNumbers option is true.\n\tfunction setGuttersForLineNumbers(options) {\n\t  var found = indexOf(options.gutters, \"CodeMirror-linenumbers\")\n\t  if (found == -1 && options.lineNumbers) {\n\t    options.gutters = options.gutters.concat([\"CodeMirror-linenumbers\"])\n\t  } else if (found > -1 && !options.lineNumbers) {\n\t    options.gutters = options.gutters.slice(0)\n\t    options.gutters.splice(found, 1)\n\t  }\n\t}\n\t\n\t// Selection objects are immutable. A new one is created every time\n\t// the selection changes. A selection is one or more non-overlapping\n\t// (and non-touching) ranges, sorted, and an integer that indicates\n\t// which one is the primary selection (the one that's scrolled into\n\t// view, that getCursor returns, etc).\n\tvar Selection = function(ranges, primIndex) {\n\t  this.ranges = ranges\n\t  this.primIndex = primIndex\n\t};\n\t\n\tSelection.prototype.primary = function () { return this.ranges[this.primIndex] };\n\t\n\tSelection.prototype.equals = function (other) {\n\t    var this$1 = this;\n\t\n\t  if (other == this) { return true }\n\t  if (other.primIndex != this.primIndex || other.ranges.length != this.ranges.length) { return false }\n\t  for (var i = 0; i < this.ranges.length; i++) {\n\t    var here = this$1.ranges[i], there = other.ranges[i]\n\t    if (!equalCursorPos(here.anchor, there.anchor) || !equalCursorPos(here.head, there.head)) { return false }\n\t  }\n\t  return true\n\t};\n\t\n\tSelection.prototype.deepCopy = function () {\n\t    var this$1 = this;\n\t\n\t  var out = []\n\t  for (var i = 0; i < this.ranges.length; i++)\n\t    { out[i] = new Range(copyPos(this$1.ranges[i].anchor), copyPos(this$1.ranges[i].head)) }\n\t  return new Selection(out, this.primIndex)\n\t};\n\t\n\tSelection.prototype.somethingSelected = function () {\n\t    var this$1 = this;\n\t\n\t  for (var i = 0; i < this.ranges.length; i++)\n\t    { if (!this$1.ranges[i].empty()) { return true } }\n\t  return false\n\t};\n\t\n\tSelection.prototype.contains = function (pos, end) {\n\t    var this$1 = this;\n\t\n\t  if (!end) { end = pos }\n\t  for (var i = 0; i < this.ranges.length; i++) {\n\t    var range = this$1.ranges[i]\n\t    if (cmp(end, range.from()) >= 0 && cmp(pos, range.to()) <= 0)\n\t      { return i }\n\t  }\n\t  return -1\n\t};\n\t\n\tvar Range = function(anchor, head) {\n\t  this.anchor = anchor; this.head = head\n\t};\n\t\n\tRange.prototype.from = function () { return minPos(this.anchor, this.head) };\n\tRange.prototype.to = function () { return maxPos(this.anchor, this.head) };\n\tRange.prototype.empty = function () { return this.head.line == this.anchor.line && this.head.ch == this.anchor.ch };\n\t\n\t// Take an unsorted, potentially overlapping set of ranges, and\n\t// build a selection out of it. 'Consumes' ranges array (modifying\n\t// it).\n\tfunction normalizeSelection(ranges, primIndex) {\n\t  var prim = ranges[primIndex]\n\t  ranges.sort(function (a, b) { return cmp(a.from(), b.from()); })\n\t  primIndex = indexOf(ranges, prim)\n\t  for (var i = 1; i < ranges.length; i++) {\n\t    var cur = ranges[i], prev = ranges[i - 1]\n\t    if (cmp(prev.to(), cur.from()) >= 0) {\n\t      var from = minPos(prev.from(), cur.from()), to = maxPos(prev.to(), cur.to())\n\t      var inv = prev.empty() ? cur.from() == cur.head : prev.from() == prev.head\n\t      if (i <= primIndex) { --primIndex }\n\t      ranges.splice(--i, 2, new Range(inv ? to : from, inv ? from : to))\n\t    }\n\t  }\n\t  return new Selection(ranges, primIndex)\n\t}\n\t\n\tfunction simpleSelection(anchor, head) {\n\t  return new Selection([new Range(anchor, head || anchor)], 0)\n\t}\n\t\n\t// Compute the position of the end of a change (its 'to' property\n\t// refers to the pre-change end).\n\tfunction changeEnd(change) {\n\t  if (!change.text) { return change.to }\n\t  return Pos(change.from.line + change.text.length - 1,\n\t             lst(change.text).length + (change.text.length == 1 ? change.from.ch : 0))\n\t}\n\t\n\t// Adjust a position to refer to the post-change position of the\n\t// same text, or the end of the change if the change covers it.\n\tfunction adjustForChange(pos, change) {\n\t  if (cmp(pos, change.from) < 0) { return pos }\n\t  if (cmp(pos, change.to) <= 0) { return changeEnd(change) }\n\t\n\t  var line = pos.line + change.text.length - (change.to.line - change.from.line) - 1, ch = pos.ch\n\t  if (pos.line == change.to.line) { ch += changeEnd(change).ch - change.to.ch }\n\t  return Pos(line, ch)\n\t}\n\t\n\tfunction computeSelAfterChange(doc, change) {\n\t  var out = []\n\t  for (var i = 0; i < doc.sel.ranges.length; i++) {\n\t    var range = doc.sel.ranges[i]\n\t    out.push(new Range(adjustForChange(range.anchor, change),\n\t                       adjustForChange(range.head, change)))\n\t  }\n\t  return normalizeSelection(out, doc.sel.primIndex)\n\t}\n\t\n\tfunction offsetPos(pos, old, nw) {\n\t  if (pos.line == old.line)\n\t    { return Pos(nw.line, pos.ch - old.ch + nw.ch) }\n\t  else\n\t    { return Pos(nw.line + (pos.line - old.line), pos.ch) }\n\t}\n\t\n\t// Used by replaceSelections to allow moving the selection to the\n\t// start or around the replaced test. Hint may be \"start\" or \"around\".\n\tfunction computeReplacedSel(doc, changes, hint) {\n\t  var out = []\n\t  var oldPrev = Pos(doc.first, 0), newPrev = oldPrev\n\t  for (var i = 0; i < changes.length; i++) {\n\t    var change = changes[i]\n\t    var from = offsetPos(change.from, oldPrev, newPrev)\n\t    var to = offsetPos(changeEnd(change), oldPrev, newPrev)\n\t    oldPrev = change.to\n\t    newPrev = to\n\t    if (hint == \"around\") {\n\t      var range = doc.sel.ranges[i], inv = cmp(range.head, range.anchor) < 0\n\t      out[i] = new Range(inv ? to : from, inv ? from : to)\n\t    } else {\n\t      out[i] = new Range(from, from)\n\t    }\n\t  }\n\t  return new Selection(out, doc.sel.primIndex)\n\t}\n\t\n\t// Used to get the editor into a consistent state again when options change.\n\t\n\tfunction loadMode(cm) {\n\t  cm.doc.mode = getMode(cm.options, cm.doc.modeOption)\n\t  resetModeState(cm)\n\t}\n\t\n\tfunction resetModeState(cm) {\n\t  cm.doc.iter(function (line) {\n\t    if (line.stateAfter) { line.stateAfter = null }\n\t    if (line.styles) { line.styles = null }\n\t  })\n\t  cm.doc.frontier = cm.doc.first\n\t  startWorker(cm, 100)\n\t  cm.state.modeGen++\n\t  if (cm.curOp) { regChange(cm) }\n\t}\n\t\n\t// DOCUMENT DATA STRUCTURE\n\t\n\t// By default, updates that start and end at the beginning of a line\n\t// are treated specially, in order to make the association of line\n\t// widgets and marker elements with the text behave more intuitive.\n\tfunction isWholeLineUpdate(doc, change) {\n\t  return change.from.ch == 0 && change.to.ch == 0 && lst(change.text) == \"\" &&\n\t    (!doc.cm || doc.cm.options.wholeLineUpdateBefore)\n\t}\n\t\n\t// Perform a change on the document data structure.\n\tfunction updateDoc(doc, change, markedSpans, estimateHeight) {\n\t  function spansFor(n) {return markedSpans ? markedSpans[n] : null}\n\t  function update(line, text, spans) {\n\t    updateLine(line, text, spans, estimateHeight)\n\t    signalLater(line, \"change\", line, change)\n\t  }\n\t  function linesFor(start, end) {\n\t    var result = []\n\t    for (var i = start; i < end; ++i)\n\t      { result.push(new Line(text[i], spansFor(i), estimateHeight)) }\n\t    return result\n\t  }\n\t\n\t  var from = change.from, to = change.to, text = change.text\n\t  var firstLine = getLine(doc, from.line), lastLine = getLine(doc, to.line)\n\t  var lastText = lst(text), lastSpans = spansFor(text.length - 1), nlines = to.line - from.line\n\t\n\t  // Adjust the line structure\n\t  if (change.full) {\n\t    doc.insert(0, linesFor(0, text.length))\n\t    doc.remove(text.length, doc.size - text.length)\n\t  } else if (isWholeLineUpdate(doc, change)) {\n\t    // This is a whole-line replace. Treated specially to make\n\t    // sure line objects move the way they are supposed to.\n\t    var added = linesFor(0, text.length - 1)\n\t    update(lastLine, lastLine.text, lastSpans)\n\t    if (nlines) { doc.remove(from.line, nlines) }\n\t    if (added.length) { doc.insert(from.line, added) }\n\t  } else if (firstLine == lastLine) {\n\t    if (text.length == 1) {\n\t      update(firstLine, firstLine.text.slice(0, from.ch) + lastText + firstLine.text.slice(to.ch), lastSpans)\n\t    } else {\n\t      var added$1 = linesFor(1, text.length - 1)\n\t      added$1.push(new Line(lastText + firstLine.text.slice(to.ch), lastSpans, estimateHeight))\n\t      update(firstLine, firstLine.text.slice(0, from.ch) + text[0], spansFor(0))\n\t      doc.insert(from.line + 1, added$1)\n\t    }\n\t  } else if (text.length == 1) {\n\t    update(firstLine, firstLine.text.slice(0, from.ch) + text[0] + lastLine.text.slice(to.ch), spansFor(0))\n\t    doc.remove(from.line + 1, nlines)\n\t  } else {\n\t    update(firstLine, firstLine.text.slice(0, from.ch) + text[0], spansFor(0))\n\t    update(lastLine, lastText + lastLine.text.slice(to.ch), lastSpans)\n\t    var added$2 = linesFor(1, text.length - 1)\n\t    if (nlines > 1) { doc.remove(from.line + 1, nlines - 1) }\n\t    doc.insert(from.line + 1, added$2)\n\t  }\n\t\n\t  signalLater(doc, \"change\", doc, change)\n\t}\n\t\n\t// Call f for all linked documents.\n\tfunction linkedDocs(doc, f, sharedHistOnly) {\n\t  function propagate(doc, skip, sharedHist) {\n\t    if (doc.linked) { for (var i = 0; i < doc.linked.length; ++i) {\n\t      var rel = doc.linked[i]\n\t      if (rel.doc == skip) { continue }\n\t      var shared = sharedHist && rel.sharedHist\n\t      if (sharedHistOnly && !shared) { continue }\n\t      f(rel.doc, shared)\n\t      propagate(rel.doc, doc, shared)\n\t    } }\n\t  }\n\t  propagate(doc, null, true)\n\t}\n\t\n\t// Attach a document to an editor.\n\tfunction attachDoc(cm, doc) {\n\t  if (doc.cm) { throw new Error(\"This document is already in use.\") }\n\t  cm.doc = doc\n\t  doc.cm = cm\n\t  estimateLineHeights(cm)\n\t  loadMode(cm)\n\t  if (!cm.options.lineWrapping) { findMaxLine(cm) }\n\t  cm.options.mode = doc.modeOption\n\t  regChange(cm)\n\t}\n\t\n\tfunction History(startGen) {\n\t  // Arrays of change events and selections. Doing something adds an\n\t  // event to done and clears undo. Undoing moves events from done\n\t  // to undone, redoing moves them in the other direction.\n\t  this.done = []; this.undone = []\n\t  this.undoDepth = Infinity\n\t  // Used to track when changes can be merged into a single undo\n\t  // event\n\t  this.lastModTime = this.lastSelTime = 0\n\t  this.lastOp = this.lastSelOp = null\n\t  this.lastOrigin = this.lastSelOrigin = null\n\t  // Used by the isClean() method\n\t  this.generation = this.maxGeneration = startGen || 1\n\t}\n\t\n\t// Create a history change event from an updateDoc-style change\n\t// object.\n\tfunction historyChangeFromChange(doc, change) {\n\t  var histChange = {from: copyPos(change.from), to: changeEnd(change), text: getBetween(doc, change.from, change.to)}\n\t  attachLocalSpans(doc, histChange, change.from.line, change.to.line + 1)\n\t  linkedDocs(doc, function (doc) { return attachLocalSpans(doc, histChange, change.from.line, change.to.line + 1); }, true)\n\t  return histChange\n\t}\n\t\n\t// Pop all selection events off the end of a history array. Stop at\n\t// a change event.\n\tfunction clearSelectionEvents(array) {\n\t  while (array.length) {\n\t    var last = lst(array)\n\t    if (last.ranges) { array.pop() }\n\t    else { break }\n\t  }\n\t}\n\t\n\t// Find the top change event in the history. Pop off selection\n\t// events that are in the way.\n\tfunction lastChangeEvent(hist, force) {\n\t  if (force) {\n\t    clearSelectionEvents(hist.done)\n\t    return lst(hist.done)\n\t  } else if (hist.done.length && !lst(hist.done).ranges) {\n\t    return lst(hist.done)\n\t  } else if (hist.done.length > 1 && !hist.done[hist.done.length - 2].ranges) {\n\t    hist.done.pop()\n\t    return lst(hist.done)\n\t  }\n\t}\n\t\n\t// Register a change in the history. Merges changes that are within\n\t// a single operation, or are close together with an origin that\n\t// allows merging (starting with \"+\") into a single event.\n\tfunction addChangeToHistory(doc, change, selAfter, opId) {\n\t  var hist = doc.history\n\t  hist.undone.length = 0\n\t  var time = +new Date, cur\n\t  var last\n\t\n\t  if ((hist.lastOp == opId ||\n\t       hist.lastOrigin == change.origin && change.origin &&\n\t       ((change.origin.charAt(0) == \"+\" && doc.cm && hist.lastModTime > time - doc.cm.options.historyEventDelay) ||\n\t        change.origin.charAt(0) == \"*\")) &&\n\t      (cur = lastChangeEvent(hist, hist.lastOp == opId))) {\n\t    // Merge this change into the last event\n\t    last = lst(cur.changes)\n\t    if (cmp(change.from, change.to) == 0 && cmp(change.from, last.to) == 0) {\n\t      // Optimized case for simple insertion -- don't want to add\n\t      // new changesets for every character typed\n\t      last.to = changeEnd(change)\n\t    } else {\n\t      // Add new sub-event\n\t      cur.changes.push(historyChangeFromChange(doc, change))\n\t    }\n\t  } else {\n\t    // Can not be merged, start a new event.\n\t    var before = lst(hist.done)\n\t    if (!before || !before.ranges)\n\t      { pushSelectionToHistory(doc.sel, hist.done) }\n\t    cur = {changes: [historyChangeFromChange(doc, change)],\n\t           generation: hist.generation}\n\t    hist.done.push(cur)\n\t    while (hist.done.length > hist.undoDepth) {\n\t      hist.done.shift()\n\t      if (!hist.done[0].ranges) { hist.done.shift() }\n\t    }\n\t  }\n\t  hist.done.push(selAfter)\n\t  hist.generation = ++hist.maxGeneration\n\t  hist.lastModTime = hist.lastSelTime = time\n\t  hist.lastOp = hist.lastSelOp = opId\n\t  hist.lastOrigin = hist.lastSelOrigin = change.origin\n\t\n\t  if (!last) { signal(doc, \"historyAdded\") }\n\t}\n\t\n\tfunction selectionEventCanBeMerged(doc, origin, prev, sel) {\n\t  var ch = origin.charAt(0)\n\t  return ch == \"*\" ||\n\t    ch == \"+\" &&\n\t    prev.ranges.length == sel.ranges.length &&\n\t    prev.somethingSelected() == sel.somethingSelected() &&\n\t    new Date - doc.history.lastSelTime <= (doc.cm ? doc.cm.options.historyEventDelay : 500)\n\t}\n\t\n\t// Called whenever the selection changes, sets the new selection as\n\t// the pending selection in the history, and pushes the old pending\n\t// selection into the 'done' array when it was significantly\n\t// different (in number of selected ranges, emptiness, or time).\n\tfunction addSelectionToHistory(doc, sel, opId, options) {\n\t  var hist = doc.history, origin = options && options.origin\n\t\n\t  // A new event is started when the previous origin does not match\n\t  // the current, or the origins don't allow matching. Origins\n\t  // starting with * are always merged, those starting with + are\n\t  // merged when similar and close together in time.\n\t  if (opId == hist.lastSelOp ||\n\t      (origin && hist.lastSelOrigin == origin &&\n\t       (hist.lastModTime == hist.lastSelTime && hist.lastOrigin == origin ||\n\t        selectionEventCanBeMerged(doc, origin, lst(hist.done), sel))))\n\t    { hist.done[hist.done.length - 1] = sel }\n\t  else\n\t    { pushSelectionToHistory(sel, hist.done) }\n\t\n\t  hist.lastSelTime = +new Date\n\t  hist.lastSelOrigin = origin\n\t  hist.lastSelOp = opId\n\t  if (options && options.clearRedo !== false)\n\t    { clearSelectionEvents(hist.undone) }\n\t}\n\t\n\tfunction pushSelectionToHistory(sel, dest) {\n\t  var top = lst(dest)\n\t  if (!(top && top.ranges && top.equals(sel)))\n\t    { dest.push(sel) }\n\t}\n\t\n\t// Used to store marked span information in the history.\n\tfunction attachLocalSpans(doc, change, from, to) {\n\t  var existing = change[\"spans_\" + doc.id], n = 0\n\t  doc.iter(Math.max(doc.first, from), Math.min(doc.first + doc.size, to), function (line) {\n\t    if (line.markedSpans)\n\t      { (existing || (existing = change[\"spans_\" + doc.id] = {}))[n] = line.markedSpans }\n\t    ++n\n\t  })\n\t}\n\t\n\t// When un/re-doing restores text containing marked spans, those\n\t// that have been explicitly cleared should not be restored.\n\tfunction removeClearedSpans(spans) {\n\t  if (!spans) { return null }\n\t  var out\n\t  for (var i = 0; i < spans.length; ++i) {\n\t    if (spans[i].marker.explicitlyCleared) { if (!out) { out = spans.slice(0, i) } }\n\t    else if (out) { out.push(spans[i]) }\n\t  }\n\t  return !out ? spans : out.length ? out : null\n\t}\n\t\n\t// Retrieve and filter the old marked spans stored in a change event.\n\tfunction getOldSpans(doc, change) {\n\t  var found = change[\"spans_\" + doc.id]\n\t  if (!found) { return null }\n\t  var nw = []\n\t  for (var i = 0; i < change.text.length; ++i)\n\t    { nw.push(removeClearedSpans(found[i])) }\n\t  return nw\n\t}\n\t\n\t// Used for un/re-doing changes from the history. Combines the\n\t// result of computing the existing spans with the set of spans that\n\t// existed in the history (so that deleting around a span and then\n\t// undoing brings back the span).\n\tfunction mergeOldSpans(doc, change) {\n\t  var old = getOldSpans(doc, change)\n\t  var stretched = stretchSpansOverChange(doc, change)\n\t  if (!old) { return stretched }\n\t  if (!stretched) { return old }\n\t\n\t  for (var i = 0; i < old.length; ++i) {\n\t    var oldCur = old[i], stretchCur = stretched[i]\n\t    if (oldCur && stretchCur) {\n\t      spans: for (var j = 0; j < stretchCur.length; ++j) {\n\t        var span = stretchCur[j]\n\t        for (var k = 0; k < oldCur.length; ++k)\n\t          { if (oldCur[k].marker == span.marker) { continue spans } }\n\t        oldCur.push(span)\n\t      }\n\t    } else if (stretchCur) {\n\t      old[i] = stretchCur\n\t    }\n\t  }\n\t  return old\n\t}\n\t\n\t// Used both to provide a JSON-safe object in .getHistory, and, when\n\t// detaching a document, to split the history in two\n\tfunction copyHistoryArray(events, newGroup, instantiateSel) {\n\t  var copy = []\n\t  for (var i = 0; i < events.length; ++i) {\n\t    var event = events[i]\n\t    if (event.ranges) {\n\t      copy.push(instantiateSel ? Selection.prototype.deepCopy.call(event) : event)\n\t      continue\n\t    }\n\t    var changes = event.changes, newChanges = []\n\t    copy.push({changes: newChanges})\n\t    for (var j = 0; j < changes.length; ++j) {\n\t      var change = changes[j], m = (void 0)\n\t      newChanges.push({from: change.from, to: change.to, text: change.text})\n\t      if (newGroup) { for (var prop in change) { if (m = prop.match(/^spans_(\\d+)$/)) {\n\t        if (indexOf(newGroup, Number(m[1])) > -1) {\n\t          lst(newChanges)[prop] = change[prop]\n\t          delete change[prop]\n\t        }\n\t      } } }\n\t    }\n\t  }\n\t  return copy\n\t}\n\t\n\t// The 'scroll' parameter given to many of these indicated whether\n\t// the new cursor position should be scrolled into view after\n\t// modifying the selection.\n\t\n\t// If shift is held or the extend flag is set, extends a range to\n\t// include a given position (and optionally a second position).\n\t// Otherwise, simply returns the range between the given positions.\n\t// Used for cursor motion and such.\n\tfunction extendRange(doc, range, head, other) {\n\t  if (doc.cm && doc.cm.display.shift || doc.extend) {\n\t    var anchor = range.anchor\n\t    if (other) {\n\t      var posBefore = cmp(head, anchor) < 0\n\t      if (posBefore != (cmp(other, anchor) < 0)) {\n\t        anchor = head\n\t        head = other\n\t      } else if (posBefore != (cmp(head, other) < 0)) {\n\t        head = other\n\t      }\n\t    }\n\t    return new Range(anchor, head)\n\t  } else {\n\t    return new Range(other || head, head)\n\t  }\n\t}\n\t\n\t// Extend the primary selection range, discard the rest.\n\tfunction extendSelection(doc, head, other, options) {\n\t  setSelection(doc, new Selection([extendRange(doc, doc.sel.primary(), head, other)], 0), options)\n\t}\n\t\n\t// Extend all selections (pos is an array of selections with length\n\t// equal the number of selections)\n\tfunction extendSelections(doc, heads, options) {\n\t  var out = []\n\t  for (var i = 0; i < doc.sel.ranges.length; i++)\n\t    { out[i] = extendRange(doc, doc.sel.ranges[i], heads[i], null) }\n\t  var newSel = normalizeSelection(out, doc.sel.primIndex)\n\t  setSelection(doc, newSel, options)\n\t}\n\t\n\t// Updates a single range in the selection.\n\tfunction replaceOneSelection(doc, i, range, options) {\n\t  var ranges = doc.sel.ranges.slice(0)\n\t  ranges[i] = range\n\t  setSelection(doc, normalizeSelection(ranges, doc.sel.primIndex), options)\n\t}\n\t\n\t// Reset the selection to a single range.\n\tfunction setSimpleSelection(doc, anchor, head, options) {\n\t  setSelection(doc, simpleSelection(anchor, head), options)\n\t}\n\t\n\t// Give beforeSelectionChange handlers a change to influence a\n\t// selection update.\n\tfunction filterSelectionChange(doc, sel, options) {\n\t  var obj = {\n\t    ranges: sel.ranges,\n\t    update: function(ranges) {\n\t      var this$1 = this;\n\t\n\t      this.ranges = []\n\t      for (var i = 0; i < ranges.length; i++)\n\t        { this$1.ranges[i] = new Range(clipPos(doc, ranges[i].anchor),\n\t                                   clipPos(doc, ranges[i].head)) }\n\t    },\n\t    origin: options && options.origin\n\t  }\n\t  signal(doc, \"beforeSelectionChange\", doc, obj)\n\t  if (doc.cm) { signal(doc.cm, \"beforeSelectionChange\", doc.cm, obj) }\n\t  if (obj.ranges != sel.ranges) { return normalizeSelection(obj.ranges, obj.ranges.length - 1) }\n\t  else { return sel }\n\t}\n\t\n\tfunction setSelectionReplaceHistory(doc, sel, options) {\n\t  var done = doc.history.done, last = lst(done)\n\t  if (last && last.ranges) {\n\t    done[done.length - 1] = sel\n\t    setSelectionNoUndo(doc, sel, options)\n\t  } else {\n\t    setSelection(doc, sel, options)\n\t  }\n\t}\n\t\n\t// Set a new selection.\n\tfunction setSelection(doc, sel, options) {\n\t  setSelectionNoUndo(doc, sel, options)\n\t  addSelectionToHistory(doc, doc.sel, doc.cm ? doc.cm.curOp.id : NaN, options)\n\t}\n\t\n\tfunction setSelectionNoUndo(doc, sel, options) {\n\t  if (hasHandler(doc, \"beforeSelectionChange\") || doc.cm && hasHandler(doc.cm, \"beforeSelectionChange\"))\n\t    { sel = filterSelectionChange(doc, sel, options) }\n\t\n\t  var bias = options && options.bias ||\n\t    (cmp(sel.primary().head, doc.sel.primary().head) < 0 ? -1 : 1)\n\t  setSelectionInner(doc, skipAtomicInSelection(doc, sel, bias, true))\n\t\n\t  if (!(options && options.scroll === false) && doc.cm)\n\t    { ensureCursorVisible(doc.cm) }\n\t}\n\t\n\tfunction setSelectionInner(doc, sel) {\n\t  if (sel.equals(doc.sel)) { return }\n\t\n\t  doc.sel = sel\n\t\n\t  if (doc.cm) {\n\t    doc.cm.curOp.updateInput = doc.cm.curOp.selectionChanged = true\n\t    signalCursorActivity(doc.cm)\n\t  }\n\t  signalLater(doc, \"cursorActivity\", doc)\n\t}\n\t\n\t// Verify that the selection does not partially select any atomic\n\t// marked ranges.\n\tfunction reCheckSelection(doc) {\n\t  setSelectionInner(doc, skipAtomicInSelection(doc, doc.sel, null, false), sel_dontScroll)\n\t}\n\t\n\t// Return a selection that does not partially select any atomic\n\t// ranges.\n\tfunction skipAtomicInSelection(doc, sel, bias, mayClear) {\n\t  var out\n\t  for (var i = 0; i < sel.ranges.length; i++) {\n\t    var range = sel.ranges[i]\n\t    var old = sel.ranges.length == doc.sel.ranges.length && doc.sel.ranges[i]\n\t    var newAnchor = skipAtomic(doc, range.anchor, old && old.anchor, bias, mayClear)\n\t    var newHead = skipAtomic(doc, range.head, old && old.head, bias, mayClear)\n\t    if (out || newAnchor != range.anchor || newHead != range.head) {\n\t      if (!out) { out = sel.ranges.slice(0, i) }\n\t      out[i] = new Range(newAnchor, newHead)\n\t    }\n\t  }\n\t  return out ? normalizeSelection(out, sel.primIndex) : sel\n\t}\n\t\n\tfunction skipAtomicInner(doc, pos, oldPos, dir, mayClear) {\n\t  var line = getLine(doc, pos.line)\n\t  if (line.markedSpans) { for (var i = 0; i < line.markedSpans.length; ++i) {\n\t    var sp = line.markedSpans[i], m = sp.marker\n\t    if ((sp.from == null || (m.inclusiveLeft ? sp.from <= pos.ch : sp.from < pos.ch)) &&\n\t        (sp.to == null || (m.inclusiveRight ? sp.to >= pos.ch : sp.to > pos.ch))) {\n\t      if (mayClear) {\n\t        signal(m, \"beforeCursorEnter\")\n\t        if (m.explicitlyCleared) {\n\t          if (!line.markedSpans) { break }\n\t          else {--i; continue}\n\t        }\n\t      }\n\t      if (!m.atomic) { continue }\n\t\n\t      if (oldPos) {\n\t        var near = m.find(dir < 0 ? 1 : -1), diff = (void 0)\n\t        if (dir < 0 ? m.inclusiveRight : m.inclusiveLeft)\n\t          { near = movePos(doc, near, -dir, near && near.line == pos.line ? line : null) }\n\t        if (near && near.line == pos.line && (diff = cmp(near, oldPos)) && (dir < 0 ? diff < 0 : diff > 0))\n\t          { return skipAtomicInner(doc, near, pos, dir, mayClear) }\n\t      }\n\t\n\t      var far = m.find(dir < 0 ? -1 : 1)\n\t      if (dir < 0 ? m.inclusiveLeft : m.inclusiveRight)\n\t        { far = movePos(doc, far, dir, far.line == pos.line ? line : null) }\n\t      return far ? skipAtomicInner(doc, far, pos, dir, mayClear) : null\n\t    }\n\t  } }\n\t  return pos\n\t}\n\t\n\t// Ensure a given position is not inside an atomic range.\n\tfunction skipAtomic(doc, pos, oldPos, bias, mayClear) {\n\t  var dir = bias || 1\n\t  var found = skipAtomicInner(doc, pos, oldPos, dir, mayClear) ||\n\t      (!mayClear && skipAtomicInner(doc, pos, oldPos, dir, true)) ||\n\t      skipAtomicInner(doc, pos, oldPos, -dir, mayClear) ||\n\t      (!mayClear && skipAtomicInner(doc, pos, oldPos, -dir, true))\n\t  if (!found) {\n\t    doc.cantEdit = true\n\t    return Pos(doc.first, 0)\n\t  }\n\t  return found\n\t}\n\t\n\tfunction movePos(doc, pos, dir, line) {\n\t  if (dir < 0 && pos.ch == 0) {\n\t    if (pos.line > doc.first) { return clipPos(doc, Pos(pos.line - 1)) }\n\t    else { return null }\n\t  } else if (dir > 0 && pos.ch == (line || getLine(doc, pos.line)).text.length) {\n\t    if (pos.line < doc.first + doc.size - 1) { return Pos(pos.line + 1, 0) }\n\t    else { return null }\n\t  } else {\n\t    return new Pos(pos.line, pos.ch + dir)\n\t  }\n\t}\n\t\n\tfunction selectAll(cm) {\n\t  cm.setSelection(Pos(cm.firstLine(), 0), Pos(cm.lastLine()), sel_dontScroll)\n\t}\n\t\n\t// UPDATING\n\t\n\t// Allow \"beforeChange\" event handlers to influence a change\n\tfunction filterChange(doc, change, update) {\n\t  var obj = {\n\t    canceled: false,\n\t    from: change.from,\n\t    to: change.to,\n\t    text: change.text,\n\t    origin: change.origin,\n\t    cancel: function () { return obj.canceled = true; }\n\t  }\n\t  if (update) { obj.update = function (from, to, text, origin) {\n\t    if (from) { obj.from = clipPos(doc, from) }\n\t    if (to) { obj.to = clipPos(doc, to) }\n\t    if (text) { obj.text = text }\n\t    if (origin !== undefined) { obj.origin = origin }\n\t  } }\n\t  signal(doc, \"beforeChange\", doc, obj)\n\t  if (doc.cm) { signal(doc.cm, \"beforeChange\", doc.cm, obj) }\n\t\n\t  if (obj.canceled) { return null }\n\t  return {from: obj.from, to: obj.to, text: obj.text, origin: obj.origin}\n\t}\n\t\n\t// Apply a change to a document, and add it to the document's\n\t// history, and propagating it to all linked documents.\n\tfunction makeChange(doc, change, ignoreReadOnly) {\n\t  if (doc.cm) {\n\t    if (!doc.cm.curOp) { return operation(doc.cm, makeChange)(doc, change, ignoreReadOnly) }\n\t    if (doc.cm.state.suppressEdits) { return }\n\t  }\n\t\n\t  if (hasHandler(doc, \"beforeChange\") || doc.cm && hasHandler(doc.cm, \"beforeChange\")) {\n\t    change = filterChange(doc, change, true)\n\t    if (!change) { return }\n\t  }\n\t\n\t  // Possibly split or suppress the update based on the presence\n\t  // of read-only spans in its range.\n\t  var split = sawReadOnlySpans && !ignoreReadOnly && removeReadOnlyRanges(doc, change.from, change.to)\n\t  if (split) {\n\t    for (var i = split.length - 1; i >= 0; --i)\n\t      { makeChangeInner(doc, {from: split[i].from, to: split[i].to, text: i ? [\"\"] : change.text}) }\n\t  } else {\n\t    makeChangeInner(doc, change)\n\t  }\n\t}\n\t\n\tfunction makeChangeInner(doc, change) {\n\t  if (change.text.length == 1 && change.text[0] == \"\" && cmp(change.from, change.to) == 0) { return }\n\t  var selAfter = computeSelAfterChange(doc, change)\n\t  addChangeToHistory(doc, change, selAfter, doc.cm ? doc.cm.curOp.id : NaN)\n\t\n\t  makeChangeSingleDoc(doc, change, selAfter, stretchSpansOverChange(doc, change))\n\t  var rebased = []\n\t\n\t  linkedDocs(doc, function (doc, sharedHist) {\n\t    if (!sharedHist && indexOf(rebased, doc.history) == -1) {\n\t      rebaseHist(doc.history, change)\n\t      rebased.push(doc.history)\n\t    }\n\t    makeChangeSingleDoc(doc, change, null, stretchSpansOverChange(doc, change))\n\t  })\n\t}\n\t\n\t// Revert a change stored in a document's history.\n\tfunction makeChangeFromHistory(doc, type, allowSelectionOnly) {\n\t  if (doc.cm && doc.cm.state.suppressEdits && !allowSelectionOnly) { return }\n\t\n\t  var hist = doc.history, event, selAfter = doc.sel\n\t  var source = type == \"undo\" ? hist.done : hist.undone, dest = type == \"undo\" ? hist.undone : hist.done\n\t\n\t  // Verify that there is a useable event (so that ctrl-z won't\n\t  // needlessly clear selection events)\n\t  var i = 0\n\t  for (; i < source.length; i++) {\n\t    event = source[i]\n\t    if (allowSelectionOnly ? event.ranges && !event.equals(doc.sel) : !event.ranges)\n\t      { break }\n\t  }\n\t  if (i == source.length) { return }\n\t  hist.lastOrigin = hist.lastSelOrigin = null\n\t\n\t  for (;;) {\n\t    event = source.pop()\n\t    if (event.ranges) {\n\t      pushSelectionToHistory(event, dest)\n\t      if (allowSelectionOnly && !event.equals(doc.sel)) {\n\t        setSelection(doc, event, {clearRedo: false})\n\t        return\n\t      }\n\t      selAfter = event\n\t    }\n\t    else { break }\n\t  }\n\t\n\t  // Build up a reverse change object to add to the opposite history\n\t  // stack (redo when undoing, and vice versa).\n\t  var antiChanges = []\n\t  pushSelectionToHistory(selAfter, dest)\n\t  dest.push({changes: antiChanges, generation: hist.generation})\n\t  hist.generation = event.generation || ++hist.maxGeneration\n\t\n\t  var filter = hasHandler(doc, \"beforeChange\") || doc.cm && hasHandler(doc.cm, \"beforeChange\")\n\t\n\t  var loop = function ( i ) {\n\t    var change = event.changes[i]\n\t    change.origin = type\n\t    if (filter && !filterChange(doc, change, false)) {\n\t      source.length = 0\n\t      return {}\n\t    }\n\t\n\t    antiChanges.push(historyChangeFromChange(doc, change))\n\t\n\t    var after = i ? computeSelAfterChange(doc, change) : lst(source)\n\t    makeChangeSingleDoc(doc, change, after, mergeOldSpans(doc, change))\n\t    if (!i && doc.cm) { doc.cm.scrollIntoView({from: change.from, to: changeEnd(change)}) }\n\t    var rebased = []\n\t\n\t    // Propagate to the linked documents\n\t    linkedDocs(doc, function (doc, sharedHist) {\n\t      if (!sharedHist && indexOf(rebased, doc.history) == -1) {\n\t        rebaseHist(doc.history, change)\n\t        rebased.push(doc.history)\n\t      }\n\t      makeChangeSingleDoc(doc, change, null, mergeOldSpans(doc, change))\n\t    })\n\t  };\n\t\n\t  for (var i$1 = event.changes.length - 1; i$1 >= 0; --i$1) {\n\t    var returned = loop( i$1 );\n\t\n\t    if ( returned ) return returned.v;\n\t  }\n\t}\n\t\n\t// Sub-views need their line numbers shifted when text is added\n\t// above or below them in the parent document.\n\tfunction shiftDoc(doc, distance) {\n\t  if (distance == 0) { return }\n\t  doc.first += distance\n\t  doc.sel = new Selection(map(doc.sel.ranges, function (range) { return new Range(\n\t    Pos(range.anchor.line + distance, range.anchor.ch),\n\t    Pos(range.head.line + distance, range.head.ch)\n\t  ); }), doc.sel.primIndex)\n\t  if (doc.cm) {\n\t    regChange(doc.cm, doc.first, doc.first - distance, distance)\n\t    for (var d = doc.cm.display, l = d.viewFrom; l < d.viewTo; l++)\n\t      { regLineChange(doc.cm, l, \"gutter\") }\n\t  }\n\t}\n\t\n\t// More lower-level change function, handling only a single document\n\t// (not linked ones).\n\tfunction makeChangeSingleDoc(doc, change, selAfter, spans) {\n\t  if (doc.cm && !doc.cm.curOp)\n\t    { return operation(doc.cm, makeChangeSingleDoc)(doc, change, selAfter, spans) }\n\t\n\t  if (change.to.line < doc.first) {\n\t    shiftDoc(doc, change.text.length - 1 - (change.to.line - change.from.line))\n\t    return\n\t  }\n\t  if (change.from.line > doc.lastLine()) { return }\n\t\n\t  // Clip the change to the size of this doc\n\t  if (change.from.line < doc.first) {\n\t    var shift = change.text.length - 1 - (doc.first - change.from.line)\n\t    shiftDoc(doc, shift)\n\t    change = {from: Pos(doc.first, 0), to: Pos(change.to.line + shift, change.to.ch),\n\t              text: [lst(change.text)], origin: change.origin}\n\t  }\n\t  var last = doc.lastLine()\n\t  if (change.to.line > last) {\n\t    change = {from: change.from, to: Pos(last, getLine(doc, last).text.length),\n\t              text: [change.text[0]], origin: change.origin}\n\t  }\n\t\n\t  change.removed = getBetween(doc, change.from, change.to)\n\t\n\t  if (!selAfter) { selAfter = computeSelAfterChange(doc, change) }\n\t  if (doc.cm) { makeChangeSingleDocInEditor(doc.cm, change, spans) }\n\t  else { updateDoc(doc, change, spans) }\n\t  setSelectionNoUndo(doc, selAfter, sel_dontScroll)\n\t}\n\t\n\t// Handle the interaction of a change to a document with the editor\n\t// that this document is part of.\n\tfunction makeChangeSingleDocInEditor(cm, change, spans) {\n\t  var doc = cm.doc, display = cm.display, from = change.from, to = change.to\n\t\n\t  var recomputeMaxLength = false, checkWidthStart = from.line\n\t  if (!cm.options.lineWrapping) {\n\t    checkWidthStart = lineNo(visualLine(getLine(doc, from.line)))\n\t    doc.iter(checkWidthStart, to.line + 1, function (line) {\n\t      if (line == display.maxLine) {\n\t        recomputeMaxLength = true\n\t        return true\n\t      }\n\t    })\n\t  }\n\t\n\t  if (doc.sel.contains(change.from, change.to) > -1)\n\t    { signalCursorActivity(cm) }\n\t\n\t  updateDoc(doc, change, spans, estimateHeight(cm))\n\t\n\t  if (!cm.options.lineWrapping) {\n\t    doc.iter(checkWidthStart, from.line + change.text.length, function (line) {\n\t      var len = lineLength(line)\n\t      if (len > display.maxLineLength) {\n\t        display.maxLine = line\n\t        display.maxLineLength = len\n\t        display.maxLineChanged = true\n\t        recomputeMaxLength = false\n\t      }\n\t    })\n\t    if (recomputeMaxLength) { cm.curOp.updateMaxLine = true }\n\t  }\n\t\n\t  // Adjust frontier, schedule worker\n\t  doc.frontier = Math.min(doc.frontier, from.line)\n\t  startWorker(cm, 400)\n\t\n\t  var lendiff = change.text.length - (to.line - from.line) - 1\n\t  // Remember that these lines changed, for updating the display\n\t  if (change.full)\n\t    { regChange(cm) }\n\t  else if (from.line == to.line && change.text.length == 1 && !isWholeLineUpdate(cm.doc, change))\n\t    { regLineChange(cm, from.line, \"text\") }\n\t  else\n\t    { regChange(cm, from.line, to.line + 1, lendiff) }\n\t\n\t  var changesHandler = hasHandler(cm, \"changes\"), changeHandler = hasHandler(cm, \"change\")\n\t  if (changeHandler || changesHandler) {\n\t    var obj = {\n\t      from: from, to: to,\n\t      text: change.text,\n\t      removed: change.removed,\n\t      origin: change.origin\n\t    }\n\t    if (changeHandler) { signalLater(cm, \"change\", cm, obj) }\n\t    if (changesHandler) { (cm.curOp.changeObjs || (cm.curOp.changeObjs = [])).push(obj) }\n\t  }\n\t  cm.display.selForContextMenu = null\n\t}\n\t\n\tfunction replaceRange(doc, code, from, to, origin) {\n\t  if (!to) { to = from }\n\t  if (cmp(to, from) < 0) { var tmp = to; to = from; from = tmp }\n\t  if (typeof code == \"string\") { code = doc.splitLines(code) }\n\t  makeChange(doc, {from: from, to: to, text: code, origin: origin})\n\t}\n\t\n\t// Rebasing/resetting history to deal with externally-sourced changes\n\t\n\tfunction rebaseHistSelSingle(pos, from, to, diff) {\n\t  if (to < pos.line) {\n\t    pos.line += diff\n\t  } else if (from < pos.line) {\n\t    pos.line = from\n\t    pos.ch = 0\n\t  }\n\t}\n\t\n\t// Tries to rebase an array of history events given a change in the\n\t// document. If the change touches the same lines as the event, the\n\t// event, and everything 'behind' it, is discarded. If the change is\n\t// before the event, the event's positions are updated. Uses a\n\t// copy-on-write scheme for the positions, to avoid having to\n\t// reallocate them all on every rebase, but also avoid problems with\n\t// shared position objects being unsafely updated.\n\tfunction rebaseHistArray(array, from, to, diff) {\n\t  for (var i = 0; i < array.length; ++i) {\n\t    var sub = array[i], ok = true\n\t    if (sub.ranges) {\n\t      if (!sub.copied) { sub = array[i] = sub.deepCopy(); sub.copied = true }\n\t      for (var j = 0; j < sub.ranges.length; j++) {\n\t        rebaseHistSelSingle(sub.ranges[j].anchor, from, to, diff)\n\t        rebaseHistSelSingle(sub.ranges[j].head, from, to, diff)\n\t      }\n\t      continue\n\t    }\n\t    for (var j$1 = 0; j$1 < sub.changes.length; ++j$1) {\n\t      var cur = sub.changes[j$1]\n\t      if (to < cur.from.line) {\n\t        cur.from = Pos(cur.from.line + diff, cur.from.ch)\n\t        cur.to = Pos(cur.to.line + diff, cur.to.ch)\n\t      } else if (from <= cur.to.line) {\n\t        ok = false\n\t        break\n\t      }\n\t    }\n\t    if (!ok) {\n\t      array.splice(0, i + 1)\n\t      i = 0\n\t    }\n\t  }\n\t}\n\t\n\tfunction rebaseHist(hist, change) {\n\t  var from = change.from.line, to = change.to.line, diff = change.text.length - (to - from) - 1\n\t  rebaseHistArray(hist.done, from, to, diff)\n\t  rebaseHistArray(hist.undone, from, to, diff)\n\t}\n\t\n\t// Utility for applying a change to a line by handle or number,\n\t// returning the number and optionally registering the line as\n\t// changed.\n\tfunction changeLine(doc, handle, changeType, op) {\n\t  var no = handle, line = handle\n\t  if (typeof handle == \"number\") { line = getLine(doc, clipLine(doc, handle)) }\n\t  else { no = lineNo(handle) }\n\t  if (no == null) { return null }\n\t  if (op(line, no) && doc.cm) { regLineChange(doc.cm, no, changeType) }\n\t  return line\n\t}\n\t\n\t// The document is represented as a BTree consisting of leaves, with\n\t// chunk of lines in them, and branches, with up to ten leaves or\n\t// other branch nodes below them. The top node is always a branch\n\t// node, and is the document object itself (meaning it has\n\t// additional methods and properties).\n\t//\n\t// All nodes have parent links. The tree is used both to go from\n\t// line numbers to line objects, and to go from objects to numbers.\n\t// It also indexes by height, and is used to convert between height\n\t// and line object, and to find the total height of the document.\n\t//\n\t// See also http://marijnhaverbeke.nl/blog/codemirror-line-tree.html\n\t\n\tvar LeafChunk = function(lines) {\n\t  var this$1 = this;\n\t\n\t  this.lines = lines\n\t  this.parent = null\n\t  var height = 0\n\t  for (var i = 0; i < lines.length; ++i) {\n\t    lines[i].parent = this$1\n\t    height += lines[i].height\n\t  }\n\t  this.height = height\n\t};\n\t\n\tLeafChunk.prototype.chunkSize = function () { return this.lines.length };\n\t\n\t// Remove the n lines at offset 'at'.\n\tLeafChunk.prototype.removeInner = function (at, n) {\n\t    var this$1 = this;\n\t\n\t  for (var i = at, e = at + n; i < e; ++i) {\n\t    var line = this$1.lines[i]\n\t    this$1.height -= line.height\n\t    cleanUpLine(line)\n\t    signalLater(line, \"delete\")\n\t  }\n\t  this.lines.splice(at, n)\n\t};\n\t\n\t// Helper used to collapse a small branch into a single leaf.\n\tLeafChunk.prototype.collapse = function (lines) {\n\t  lines.push.apply(lines, this.lines)\n\t};\n\t\n\t// Insert the given array of lines at offset 'at', count them as\n\t// having the given height.\n\tLeafChunk.prototype.insertInner = function (at, lines, height) {\n\t    var this$1 = this;\n\t\n\t  this.height += height\n\t  this.lines = this.lines.slice(0, at).concat(lines).concat(this.lines.slice(at))\n\t  for (var i = 0; i < lines.length; ++i) { lines[i].parent = this$1 }\n\t};\n\t\n\t// Used to iterate over a part of the tree.\n\tLeafChunk.prototype.iterN = function (at, n, op) {\n\t    var this$1 = this;\n\t\n\t  for (var e = at + n; at < e; ++at)\n\t    { if (op(this$1.lines[at])) { return true } }\n\t};\n\t\n\tvar BranchChunk = function(children) {\n\t  var this$1 = this;\n\t\n\t  this.children = children\n\t  var size = 0, height = 0\n\t  for (var i = 0; i < children.length; ++i) {\n\t    var ch = children[i]\n\t    size += ch.chunkSize(); height += ch.height\n\t    ch.parent = this$1\n\t  }\n\t  this.size = size\n\t  this.height = height\n\t  this.parent = null\n\t};\n\t\n\tBranchChunk.prototype.chunkSize = function () { return this.size };\n\t\n\tBranchChunk.prototype.removeInner = function (at, n) {\n\t    var this$1 = this;\n\t\n\t  this.size -= n\n\t  for (var i = 0; i < this.children.length; ++i) {\n\t    var child = this$1.children[i], sz = child.chunkSize()\n\t    if (at < sz) {\n\t      var rm = Math.min(n, sz - at), oldHeight = child.height\n\t      child.removeInner(at, rm)\n\t      this$1.height -= oldHeight - child.height\n\t      if (sz == rm) { this$1.children.splice(i--, 1); child.parent = null }\n\t      if ((n -= rm) == 0) { break }\n\t      at = 0\n\t    } else { at -= sz }\n\t  }\n\t  // If the result is smaller than 25 lines, ensure that it is a\n\t  // single leaf node.\n\t  if (this.size - n < 25 &&\n\t      (this.children.length > 1 || !(this.children[0] instanceof LeafChunk))) {\n\t    var lines = []\n\t    this.collapse(lines)\n\t    this.children = [new LeafChunk(lines)]\n\t    this.children[0].parent = this\n\t  }\n\t};\n\t\n\tBranchChunk.prototype.collapse = function (lines) {\n\t    var this$1 = this;\n\t\n\t  for (var i = 0; i < this.children.length; ++i) { this$1.children[i].collapse(lines) }\n\t};\n\t\n\tBranchChunk.prototype.insertInner = function (at, lines, height) {\n\t    var this$1 = this;\n\t\n\t  this.size += lines.length\n\t  this.height += height\n\t  for (var i = 0; i < this.children.length; ++i) {\n\t    var child = this$1.children[i], sz = child.chunkSize()\n\t    if (at <= sz) {\n\t      child.insertInner(at, lines, height)\n\t      if (child.lines && child.lines.length > 50) {\n\t        // To avoid memory thrashing when child.lines is huge (e.g. first view of a large file), it's never spliced.\n\t        // Instead, small slices are taken. They're taken in order because sequential memory accesses are fastest.\n\t        var remaining = child.lines.length % 25 + 25\n\t        for (var pos = remaining; pos < child.lines.length;) {\n\t          var leaf = new LeafChunk(child.lines.slice(pos, pos += 25))\n\t          child.height -= leaf.height\n\t          this$1.children.splice(++i, 0, leaf)\n\t          leaf.parent = this$1\n\t        }\n\t        child.lines = child.lines.slice(0, remaining)\n\t        this$1.maybeSpill()\n\t      }\n\t      break\n\t    }\n\t    at -= sz\n\t  }\n\t};\n\t\n\t// When a node has grown, check whether it should be split.\n\tBranchChunk.prototype.maybeSpill = function () {\n\t  if (this.children.length <= 10) { return }\n\t  var me = this\n\t  do {\n\t    var spilled = me.children.splice(me.children.length - 5, 5)\n\t    var sibling = new BranchChunk(spilled)\n\t    if (!me.parent) { // Become the parent node\n\t      var copy = new BranchChunk(me.children)\n\t      copy.parent = me\n\t      me.children = [copy, sibling]\n\t      me = copy\n\t   } else {\n\t      me.size -= sibling.size\n\t      me.height -= sibling.height\n\t      var myIndex = indexOf(me.parent.children, me)\n\t      me.parent.children.splice(myIndex + 1, 0, sibling)\n\t    }\n\t    sibling.parent = me.parent\n\t  } while (me.children.length > 10)\n\t  me.parent.maybeSpill()\n\t};\n\t\n\tBranchChunk.prototype.iterN = function (at, n, op) {\n\t    var this$1 = this;\n\t\n\t  for (var i = 0; i < this.children.length; ++i) {\n\t    var child = this$1.children[i], sz = child.chunkSize()\n\t    if (at < sz) {\n\t      var used = Math.min(n, sz - at)\n\t      if (child.iterN(at, used, op)) { return true }\n\t      if ((n -= used) == 0) { break }\n\t      at = 0\n\t    } else { at -= sz }\n\t  }\n\t};\n\t\n\t// Line widgets are block elements displayed above or below a line.\n\t\n\tvar LineWidget = function(doc, node, options) {\n\t  var this$1 = this;\n\t\n\t  if (options) { for (var opt in options) { if (options.hasOwnProperty(opt))\n\t    { this$1[opt] = options[opt] } } }\n\t  this.doc = doc\n\t  this.node = node\n\t};\n\t\n\tLineWidget.prototype.clear = function () {\n\t    var this$1 = this;\n\t\n\t  var cm = this.doc.cm, ws = this.line.widgets, line = this.line, no = lineNo(line)\n\t  if (no == null || !ws) { return }\n\t  for (var i = 0; i < ws.length; ++i) { if (ws[i] == this$1) { ws.splice(i--, 1) } }\n\t  if (!ws.length) { line.widgets = null }\n\t  var height = widgetHeight(this)\n\t  updateLineHeight(line, Math.max(0, line.height - height))\n\t  if (cm) {\n\t    runInOp(cm, function () {\n\t      adjustScrollWhenAboveVisible(cm, line, -height)\n\t      regLineChange(cm, no, \"widget\")\n\t    })\n\t    signalLater(cm, \"lineWidgetCleared\", cm, this, no)\n\t  }\n\t};\n\t\n\tLineWidget.prototype.changed = function () {\n\t    var this$1 = this;\n\t\n\t  var oldH = this.height, cm = this.doc.cm, line = this.line\n\t  this.height = null\n\t  var diff = widgetHeight(this) - oldH\n\t  if (!diff) { return }\n\t  updateLineHeight(line, line.height + diff)\n\t  if (cm) {\n\t    runInOp(cm, function () {\n\t      cm.curOp.forceUpdate = true\n\t      adjustScrollWhenAboveVisible(cm, line, diff)\n\t      signalLater(cm, \"lineWidgetChanged\", cm, this$1, lineNo(line))\n\t    })\n\t  }\n\t};\n\teventMixin(LineWidget)\n\t\n\tfunction adjustScrollWhenAboveVisible(cm, line, diff) {\n\t  if (heightAtLine(line) < ((cm.curOp && cm.curOp.scrollTop) || cm.doc.scrollTop))\n\t    { addToScrollPos(cm, null, diff) }\n\t}\n\t\n\tfunction addLineWidget(doc, handle, node, options) {\n\t  var widget = new LineWidget(doc, node, options)\n\t  var cm = doc.cm\n\t  if (cm && widget.noHScroll) { cm.display.alignWidgets = true }\n\t  changeLine(doc, handle, \"widget\", function (line) {\n\t    var widgets = line.widgets || (line.widgets = [])\n\t    if (widget.insertAt == null) { widgets.push(widget) }\n\t    else { widgets.splice(Math.min(widgets.length - 1, Math.max(0, widget.insertAt)), 0, widget) }\n\t    widget.line = line\n\t    if (cm && !lineIsHidden(doc, line)) {\n\t      var aboveVisible = heightAtLine(line) < doc.scrollTop\n\t      updateLineHeight(line, line.height + widgetHeight(widget))\n\t      if (aboveVisible) { addToScrollPos(cm, null, widget.height) }\n\t      cm.curOp.forceUpdate = true\n\t    }\n\t    return true\n\t  })\n\t  signalLater(cm, \"lineWidgetAdded\", cm, widget, typeof handle == \"number\" ? handle : lineNo(handle))\n\t  return widget\n\t}\n\t\n\t// TEXTMARKERS\n\t\n\t// Created with markText and setBookmark methods. A TextMarker is a\n\t// handle that can be used to clear or find a marked position in the\n\t// document. Line objects hold arrays (markedSpans) containing\n\t// {from, to, marker} object pointing to such marker objects, and\n\t// indicating that such a marker is present on that line. Multiple\n\t// lines may point to the same marker when it spans across lines.\n\t// The spans will have null for their from/to properties when the\n\t// marker continues beyond the start/end of the line. Markers have\n\t// links back to the lines they currently touch.\n\t\n\t// Collapsed markers have unique ids, in order to be able to order\n\t// them, which is needed for uniquely determining an outer marker\n\t// when they overlap (they may nest, but not partially overlap).\n\tvar nextMarkerId = 0\n\t\n\tvar TextMarker = function(doc, type) {\n\t  this.lines = []\n\t  this.type = type\n\t  this.doc = doc\n\t  this.id = ++nextMarkerId\n\t};\n\t\n\t// Clear the marker.\n\tTextMarker.prototype.clear = function () {\n\t    var this$1 = this;\n\t\n\t  if (this.explicitlyCleared) { return }\n\t  var cm = this.doc.cm, withOp = cm && !cm.curOp\n\t  if (withOp) { startOperation(cm) }\n\t  if (hasHandler(this, \"clear\")) {\n\t    var found = this.find()\n\t    if (found) { signalLater(this, \"clear\", found.from, found.to) }\n\t  }\n\t  var min = null, max = null\n\t  for (var i = 0; i < this.lines.length; ++i) {\n\t    var line = this$1.lines[i]\n\t    var span = getMarkedSpanFor(line.markedSpans, this$1)\n\t    if (cm && !this$1.collapsed) { regLineChange(cm, lineNo(line), \"text\") }\n\t    else if (cm) {\n\t      if (span.to != null) { max = lineNo(line) }\n\t      if (span.from != null) { min = lineNo(line) }\n\t    }\n\t    line.markedSpans = removeMarkedSpan(line.markedSpans, span)\n\t    if (span.from == null && this$1.collapsed && !lineIsHidden(this$1.doc, line) && cm)\n\t      { updateLineHeight(line, textHeight(cm.display)) }\n\t  }\n\t  if (cm && this.collapsed && !cm.options.lineWrapping) { for (var i$1 = 0; i$1 < this.lines.length; ++i$1) {\n\t    var visual = visualLine(this$1.lines[i$1]), len = lineLength(visual)\n\t    if (len > cm.display.maxLineLength) {\n\t      cm.display.maxLine = visual\n\t      cm.display.maxLineLength = len\n\t      cm.display.maxLineChanged = true\n\t    }\n\t  } }\n\t\n\t  if (min != null && cm && this.collapsed) { regChange(cm, min, max + 1) }\n\t  this.lines.length = 0\n\t  this.explicitlyCleared = true\n\t  if (this.atomic && this.doc.cantEdit) {\n\t    this.doc.cantEdit = false\n\t    if (cm) { reCheckSelection(cm.doc) }\n\t  }\n\t  if (cm) { signalLater(cm, \"markerCleared\", cm, this, min, max) }\n\t  if (withOp) { endOperation(cm) }\n\t  if (this.parent) { this.parent.clear() }\n\t};\n\t\n\t// Find the position of the marker in the document. Returns a {from,\n\t// to} object by default. Side can be passed to get a specific side\n\t// -- 0 (both), -1 (left), or 1 (right). When lineObj is true, the\n\t// Pos objects returned contain a line object, rather than a line\n\t// number (used to prevent looking up the same line twice).\n\tTextMarker.prototype.find = function (side, lineObj) {\n\t    var this$1 = this;\n\t\n\t  if (side == null && this.type == \"bookmark\") { side = 1 }\n\t  var from, to\n\t  for (var i = 0; i < this.lines.length; ++i) {\n\t    var line = this$1.lines[i]\n\t    var span = getMarkedSpanFor(line.markedSpans, this$1)\n\t    if (span.from != null) {\n\t      from = Pos(lineObj ? line : lineNo(line), span.from)\n\t      if (side == -1) { return from }\n\t    }\n\t    if (span.to != null) {\n\t      to = Pos(lineObj ? line : lineNo(line), span.to)\n\t      if (side == 1) { return to }\n\t    }\n\t  }\n\t  return from && {from: from, to: to}\n\t};\n\t\n\t// Signals that the marker's widget changed, and surrounding layout\n\t// should be recomputed.\n\tTextMarker.prototype.changed = function () {\n\t    var this$1 = this;\n\t\n\t  var pos = this.find(-1, true), widget = this, cm = this.doc.cm\n\t  if (!pos || !cm) { return }\n\t  runInOp(cm, function () {\n\t    var line = pos.line, lineN = lineNo(pos.line)\n\t    var view = findViewForLine(cm, lineN)\n\t    if (view) {\n\t      clearLineMeasurementCacheFor(view)\n\t      cm.curOp.selectionChanged = cm.curOp.forceUpdate = true\n\t    }\n\t    cm.curOp.updateMaxLine = true\n\t    if (!lineIsHidden(widget.doc, line) && widget.height != null) {\n\t      var oldHeight = widget.height\n\t      widget.height = null\n\t      var dHeight = widgetHeight(widget) - oldHeight\n\t      if (dHeight)\n\t        { updateLineHeight(line, line.height + dHeight) }\n\t    }\n\t    signalLater(cm, \"markerChanged\", cm, this$1)\n\t  })\n\t};\n\t\n\tTextMarker.prototype.attachLine = function (line) {\n\t  if (!this.lines.length && this.doc.cm) {\n\t    var op = this.doc.cm.curOp\n\t    if (!op.maybeHiddenMarkers || indexOf(op.maybeHiddenMarkers, this) == -1)\n\t      { (op.maybeUnhiddenMarkers || (op.maybeUnhiddenMarkers = [])).push(this) }\n\t  }\n\t  this.lines.push(line)\n\t};\n\t\n\tTextMarker.prototype.detachLine = function (line) {\n\t  this.lines.splice(indexOf(this.lines, line), 1)\n\t  if (!this.lines.length && this.doc.cm) {\n\t    var op = this.doc.cm.curOp\n\t    ;(op.maybeHiddenMarkers || (op.maybeHiddenMarkers = [])).push(this)\n\t  }\n\t};\n\teventMixin(TextMarker)\n\t\n\t// Create a marker, wire it up to the right lines, and\n\tfunction markText(doc, from, to, options, type) {\n\t  // Shared markers (across linked documents) are handled separately\n\t  // (markTextShared will call out to this again, once per\n\t  // document).\n\t  if (options && options.shared) { return markTextShared(doc, from, to, options, type) }\n\t  // Ensure we are in an operation.\n\t  if (doc.cm && !doc.cm.curOp) { return operation(doc.cm, markText)(doc, from, to, options, type) }\n\t\n\t  var marker = new TextMarker(doc, type), diff = cmp(from, to)\n\t  if (options) { copyObj(options, marker, false) }\n\t  // Don't connect empty markers unless clearWhenEmpty is false\n\t  if (diff > 0 || diff == 0 && marker.clearWhenEmpty !== false)\n\t    { return marker }\n\t  if (marker.replacedWith) {\n\t    // Showing up as a widget implies collapsed (widget replaces text)\n\t    marker.collapsed = true\n\t    marker.widgetNode = elt(\"span\", [marker.replacedWith], \"CodeMirror-widget\")\n\t    marker.widgetNode.setAttribute(\"role\", \"presentation\") // hide from accessibility tree\n\t    if (!options.handleMouseEvents) { marker.widgetNode.setAttribute(\"cm-ignore-events\", \"true\") }\n\t    if (options.insertLeft) { marker.widgetNode.insertLeft = true }\n\t  }\n\t  if (marker.collapsed) {\n\t    if (conflictingCollapsedRange(doc, from.line, from, to, marker) ||\n\t        from.line != to.line && conflictingCollapsedRange(doc, to.line, from, to, marker))\n\t      { throw new Error(\"Inserting collapsed marker partially overlapping an existing one\") }\n\t    seeCollapsedSpans()\n\t  }\n\t\n\t  if (marker.addToHistory)\n\t    { addChangeToHistory(doc, {from: from, to: to, origin: \"markText\"}, doc.sel, NaN) }\n\t\n\t  var curLine = from.line, cm = doc.cm, updateMaxLine\n\t  doc.iter(curLine, to.line + 1, function (line) {\n\t    if (cm && marker.collapsed && !cm.options.lineWrapping && visualLine(line) == cm.display.maxLine)\n\t      { updateMaxLine = true }\n\t    if (marker.collapsed && curLine != from.line) { updateLineHeight(line, 0) }\n\t    addMarkedSpan(line, new MarkedSpan(marker,\n\t                                       curLine == from.line ? from.ch : null,\n\t                                       curLine == to.line ? to.ch : null))\n\t    ++curLine\n\t  })\n\t  // lineIsHidden depends on the presence of the spans, so needs a second pass\n\t  if (marker.collapsed) { doc.iter(from.line, to.line + 1, function (line) {\n\t    if (lineIsHidden(doc, line)) { updateLineHeight(line, 0) }\n\t  }) }\n\t\n\t  if (marker.clearOnEnter) { on(marker, \"beforeCursorEnter\", function () { return marker.clear(); }) }\n\t\n\t  if (marker.readOnly) {\n\t    seeReadOnlySpans()\n\t    if (doc.history.done.length || doc.history.undone.length)\n\t      { doc.clearHistory() }\n\t  }\n\t  if (marker.collapsed) {\n\t    marker.id = ++nextMarkerId\n\t    marker.atomic = true\n\t  }\n\t  if (cm) {\n\t    // Sync editor state\n\t    if (updateMaxLine) { cm.curOp.updateMaxLine = true }\n\t    if (marker.collapsed)\n\t      { regChange(cm, from.line, to.line + 1) }\n\t    else if (marker.className || marker.title || marker.startStyle || marker.endStyle || marker.css)\n\t      { for (var i = from.line; i <= to.line; i++) { regLineChange(cm, i, \"text\") } }\n\t    if (marker.atomic) { reCheckSelection(cm.doc) }\n\t    signalLater(cm, \"markerAdded\", cm, marker)\n\t  }\n\t  return marker\n\t}\n\t\n\t// SHARED TEXTMARKERS\n\t\n\t// A shared marker spans multiple linked documents. It is\n\t// implemented as a meta-marker-object controlling multiple normal\n\t// markers.\n\tvar SharedTextMarker = function(markers, primary) {\n\t  var this$1 = this;\n\t\n\t  this.markers = markers\n\t  this.primary = primary\n\t  for (var i = 0; i < markers.length; ++i)\n\t    { markers[i].parent = this$1 }\n\t};\n\t\n\tSharedTextMarker.prototype.clear = function () {\n\t    var this$1 = this;\n\t\n\t  if (this.explicitlyCleared) { return }\n\t  this.explicitlyCleared = true\n\t  for (var i = 0; i < this.markers.length; ++i)\n\t    { this$1.markers[i].clear() }\n\t  signalLater(this, \"clear\")\n\t};\n\t\n\tSharedTextMarker.prototype.find = function (side, lineObj) {\n\t  return this.primary.find(side, lineObj)\n\t};\n\teventMixin(SharedTextMarker)\n\t\n\tfunction markTextShared(doc, from, to, options, type) {\n\t  options = copyObj(options)\n\t  options.shared = false\n\t  var markers = [markText(doc, from, to, options, type)], primary = markers[0]\n\t  var widget = options.widgetNode\n\t  linkedDocs(doc, function (doc) {\n\t    if (widget) { options.widgetNode = widget.cloneNode(true) }\n\t    markers.push(markText(doc, clipPos(doc, from), clipPos(doc, to), options, type))\n\t    for (var i = 0; i < doc.linked.length; ++i)\n\t      { if (doc.linked[i].isParent) { return } }\n\t    primary = lst(markers)\n\t  })\n\t  return new SharedTextMarker(markers, primary)\n\t}\n\t\n\tfunction findSharedMarkers(doc) {\n\t  return doc.findMarks(Pos(doc.first, 0), doc.clipPos(Pos(doc.lastLine())), function (m) { return m.parent; })\n\t}\n\t\n\tfunction copySharedMarkers(doc, markers) {\n\t  for (var i = 0; i < markers.length; i++) {\n\t    var marker = markers[i], pos = marker.find()\n\t    var mFrom = doc.clipPos(pos.from), mTo = doc.clipPos(pos.to)\n\t    if (cmp(mFrom, mTo)) {\n\t      var subMark = markText(doc, mFrom, mTo, marker.primary, marker.primary.type)\n\t      marker.markers.push(subMark)\n\t      subMark.parent = marker\n\t    }\n\t  }\n\t}\n\t\n\tfunction detachSharedMarkers(markers) {\n\t  var loop = function ( i ) {\n\t    var marker = markers[i], linked = [marker.primary.doc]\n\t    linkedDocs(marker.primary.doc, function (d) { return linked.push(d); })\n\t    for (var j = 0; j < marker.markers.length; j++) {\n\t      var subMarker = marker.markers[j]\n\t      if (indexOf(linked, subMarker.doc) == -1) {\n\t        subMarker.parent = null\n\t        marker.markers.splice(j--, 1)\n\t      }\n\t    }\n\t  };\n\t\n\t  for (var i = 0; i < markers.length; i++) loop( i );\n\t}\n\t\n\tvar nextDocId = 0\n\tvar Doc = function(text, mode, firstLine, lineSep) {\n\t  if (!(this instanceof Doc)) { return new Doc(text, mode, firstLine, lineSep) }\n\t  if (firstLine == null) { firstLine = 0 }\n\t\n\t  BranchChunk.call(this, [new LeafChunk([new Line(\"\", null)])])\n\t  this.first = firstLine\n\t  this.scrollTop = this.scrollLeft = 0\n\t  this.cantEdit = false\n\t  this.cleanGeneration = 1\n\t  this.frontier = firstLine\n\t  var start = Pos(firstLine, 0)\n\t  this.sel = simpleSelection(start)\n\t  this.history = new History(null)\n\t  this.id = ++nextDocId\n\t  this.modeOption = mode\n\t  this.lineSep = lineSep\n\t  this.extend = false\n\t\n\t  if (typeof text == \"string\") { text = this.splitLines(text) }\n\t  updateDoc(this, {from: start, to: start, text: text})\n\t  setSelection(this, simpleSelection(start), sel_dontScroll)\n\t}\n\t\n\tDoc.prototype = createObj(BranchChunk.prototype, {\n\t  constructor: Doc,\n\t  // Iterate over the document. Supports two forms -- with only one\n\t  // argument, it calls that for each line in the document. With\n\t  // three, it iterates over the range given by the first two (with\n\t  // the second being non-inclusive).\n\t  iter: function(from, to, op) {\n\t    if (op) { this.iterN(from - this.first, to - from, op) }\n\t    else { this.iterN(this.first, this.first + this.size, from) }\n\t  },\n\t\n\t  // Non-public interface for adding and removing lines.\n\t  insert: function(at, lines) {\n\t    var height = 0\n\t    for (var i = 0; i < lines.length; ++i) { height += lines[i].height }\n\t    this.insertInner(at - this.first, lines, height)\n\t  },\n\t  remove: function(at, n) { this.removeInner(at - this.first, n) },\n\t\n\t  // From here, the methods are part of the public interface. Most\n\t  // are also available from CodeMirror (editor) instances.\n\t\n\t  getValue: function(lineSep) {\n\t    var lines = getLines(this, this.first, this.first + this.size)\n\t    if (lineSep === false) { return lines }\n\t    return lines.join(lineSep || this.lineSeparator())\n\t  },\n\t  setValue: docMethodOp(function(code) {\n\t    var top = Pos(this.first, 0), last = this.first + this.size - 1\n\t    makeChange(this, {from: top, to: Pos(last, getLine(this, last).text.length),\n\t                      text: this.splitLines(code), origin: \"setValue\", full: true}, true)\n\t    setSelection(this, simpleSelection(top))\n\t  }),\n\t  replaceRange: function(code, from, to, origin) {\n\t    from = clipPos(this, from)\n\t    to = to ? clipPos(this, to) : from\n\t    replaceRange(this, code, from, to, origin)\n\t  },\n\t  getRange: function(from, to, lineSep) {\n\t    var lines = getBetween(this, clipPos(this, from), clipPos(this, to))\n\t    if (lineSep === false) { return lines }\n\t    return lines.join(lineSep || this.lineSeparator())\n\t  },\n\t\n\t  getLine: function(line) {var l = this.getLineHandle(line); return l && l.text},\n\t\n\t  getLineHandle: function(line) {if (isLine(this, line)) { return getLine(this, line) }},\n\t  getLineNumber: function(line) {return lineNo(line)},\n\t\n\t  getLineHandleVisualStart: function(line) {\n\t    if (typeof line == \"number\") { line = getLine(this, line) }\n\t    return visualLine(line)\n\t  },\n\t\n\t  lineCount: function() {return this.size},\n\t  firstLine: function() {return this.first},\n\t  lastLine: function() {return this.first + this.size - 1},\n\t\n\t  clipPos: function(pos) {return clipPos(this, pos)},\n\t\n\t  getCursor: function(start) {\n\t    var range = this.sel.primary(), pos\n\t    if (start == null || start == \"head\") { pos = range.head }\n\t    else if (start == \"anchor\") { pos = range.anchor }\n\t    else if (start == \"end\" || start == \"to\" || start === false) { pos = range.to() }\n\t    else { pos = range.from() }\n\t    return pos\n\t  },\n\t  listSelections: function() { return this.sel.ranges },\n\t  somethingSelected: function() {return this.sel.somethingSelected()},\n\t\n\t  setCursor: docMethodOp(function(line, ch, options) {\n\t    setSimpleSelection(this, clipPos(this, typeof line == \"number\" ? Pos(line, ch || 0) : line), null, options)\n\t  }),\n\t  setSelection: docMethodOp(function(anchor, head, options) {\n\t    setSimpleSelection(this, clipPos(this, anchor), clipPos(this, head || anchor), options)\n\t  }),\n\t  extendSelection: docMethodOp(function(head, other, options) {\n\t    extendSelection(this, clipPos(this, head), other && clipPos(this, other), options)\n\t  }),\n\t  extendSelections: docMethodOp(function(heads, options) {\n\t    extendSelections(this, clipPosArray(this, heads), options)\n\t  }),\n\t  extendSelectionsBy: docMethodOp(function(f, options) {\n\t    var heads = map(this.sel.ranges, f)\n\t    extendSelections(this, clipPosArray(this, heads), options)\n\t  }),\n\t  setSelections: docMethodOp(function(ranges, primary, options) {\n\t    var this$1 = this;\n\t\n\t    if (!ranges.length) { return }\n\t    var out = []\n\t    for (var i = 0; i < ranges.length; i++)\n\t      { out[i] = new Range(clipPos(this$1, ranges[i].anchor),\n\t                         clipPos(this$1, ranges[i].head)) }\n\t    if (primary == null) { primary = Math.min(ranges.length - 1, this.sel.primIndex) }\n\t    setSelection(this, normalizeSelection(out, primary), options)\n\t  }),\n\t  addSelection: docMethodOp(function(anchor, head, options) {\n\t    var ranges = this.sel.ranges.slice(0)\n\t    ranges.push(new Range(clipPos(this, anchor), clipPos(this, head || anchor)))\n\t    setSelection(this, normalizeSelection(ranges, ranges.length - 1), options)\n\t  }),\n\t\n\t  getSelection: function(lineSep) {\n\t    var this$1 = this;\n\t\n\t    var ranges = this.sel.ranges, lines\n\t    for (var i = 0; i < ranges.length; i++) {\n\t      var sel = getBetween(this$1, ranges[i].from(), ranges[i].to())\n\t      lines = lines ? lines.concat(sel) : sel\n\t    }\n\t    if (lineSep === false) { return lines }\n\t    else { return lines.join(lineSep || this.lineSeparator()) }\n\t  },\n\t  getSelections: function(lineSep) {\n\t    var this$1 = this;\n\t\n\t    var parts = [], ranges = this.sel.ranges\n\t    for (var i = 0; i < ranges.length; i++) {\n\t      var sel = getBetween(this$1, ranges[i].from(), ranges[i].to())\n\t      if (lineSep !== false) { sel = sel.join(lineSep || this$1.lineSeparator()) }\n\t      parts[i] = sel\n\t    }\n\t    return parts\n\t  },\n\t  replaceSelection: function(code, collapse, origin) {\n\t    var dup = []\n\t    for (var i = 0; i < this.sel.ranges.length; i++)\n\t      { dup[i] = code }\n\t    this.replaceSelections(dup, collapse, origin || \"+input\")\n\t  },\n\t  replaceSelections: docMethodOp(function(code, collapse, origin) {\n\t    var this$1 = this;\n\t\n\t    var changes = [], sel = this.sel\n\t    for (var i = 0; i < sel.ranges.length; i++) {\n\t      var range = sel.ranges[i]\n\t      changes[i] = {from: range.from(), to: range.to(), text: this$1.splitLines(code[i]), origin: origin}\n\t    }\n\t    var newSel = collapse && collapse != \"end\" && computeReplacedSel(this, changes, collapse)\n\t    for (var i$1 = changes.length - 1; i$1 >= 0; i$1--)\n\t      { makeChange(this$1, changes[i$1]) }\n\t    if (newSel) { setSelectionReplaceHistory(this, newSel) }\n\t    else if (this.cm) { ensureCursorVisible(this.cm) }\n\t  }),\n\t  undo: docMethodOp(function() {makeChangeFromHistory(this, \"undo\")}),\n\t  redo: docMethodOp(function() {makeChangeFromHistory(this, \"redo\")}),\n\t  undoSelection: docMethodOp(function() {makeChangeFromHistory(this, \"undo\", true)}),\n\t  redoSelection: docMethodOp(function() {makeChangeFromHistory(this, \"redo\", true)}),\n\t\n\t  setExtending: function(val) {this.extend = val},\n\t  getExtending: function() {return this.extend},\n\t\n\t  historySize: function() {\n\t    var hist = this.history, done = 0, undone = 0\n\t    for (var i = 0; i < hist.done.length; i++) { if (!hist.done[i].ranges) { ++done } }\n\t    for (var i$1 = 0; i$1 < hist.undone.length; i$1++) { if (!hist.undone[i$1].ranges) { ++undone } }\n\t    return {undo: done, redo: undone}\n\t  },\n\t  clearHistory: function() {this.history = new History(this.history.maxGeneration)},\n\t\n\t  markClean: function() {\n\t    this.cleanGeneration = this.changeGeneration(true)\n\t  },\n\t  changeGeneration: function(forceSplit) {\n\t    if (forceSplit)\n\t      { this.history.lastOp = this.history.lastSelOp = this.history.lastOrigin = null }\n\t    return this.history.generation\n\t  },\n\t  isClean: function (gen) {\n\t    return this.history.generation == (gen || this.cleanGeneration)\n\t  },\n\t\n\t  getHistory: function() {\n\t    return {done: copyHistoryArray(this.history.done),\n\t            undone: copyHistoryArray(this.history.undone)}\n\t  },\n\t  setHistory: function(histData) {\n\t    var hist = this.history = new History(this.history.maxGeneration)\n\t    hist.done = copyHistoryArray(histData.done.slice(0), null, true)\n\t    hist.undone = copyHistoryArray(histData.undone.slice(0), null, true)\n\t  },\n\t\n\t  setGutterMarker: docMethodOp(function(line, gutterID, value) {\n\t    return changeLine(this, line, \"gutter\", function (line) {\n\t      var markers = line.gutterMarkers || (line.gutterMarkers = {})\n\t      markers[gutterID] = value\n\t      if (!value && isEmpty(markers)) { line.gutterMarkers = null }\n\t      return true\n\t    })\n\t  }),\n\t\n\t  clearGutter: docMethodOp(function(gutterID) {\n\t    var this$1 = this;\n\t\n\t    this.iter(function (line) {\n\t      if (line.gutterMarkers && line.gutterMarkers[gutterID]) {\n\t        changeLine(this$1, line, \"gutter\", function () {\n\t          line.gutterMarkers[gutterID] = null\n\t          if (isEmpty(line.gutterMarkers)) { line.gutterMarkers = null }\n\t          return true\n\t        })\n\t      }\n\t    })\n\t  }),\n\t\n\t  lineInfo: function(line) {\n\t    var n\n\t    if (typeof line == \"number\") {\n\t      if (!isLine(this, line)) { return null }\n\t      n = line\n\t      line = getLine(this, line)\n\t      if (!line) { return null }\n\t    } else {\n\t      n = lineNo(line)\n\t      if (n == null) { return null }\n\t    }\n\t    return {line: n, handle: line, text: line.text, gutterMarkers: line.gutterMarkers,\n\t            textClass: line.textClass, bgClass: line.bgClass, wrapClass: line.wrapClass,\n\t            widgets: line.widgets}\n\t  },\n\t\n\t  addLineClass: docMethodOp(function(handle, where, cls) {\n\t    return changeLine(this, handle, where == \"gutter\" ? \"gutter\" : \"class\", function (line) {\n\t      var prop = where == \"text\" ? \"textClass\"\n\t               : where == \"background\" ? \"bgClass\"\n\t               : where == \"gutter\" ? \"gutterClass\" : \"wrapClass\"\n\t      if (!line[prop]) { line[prop] = cls }\n\t      else if (classTest(cls).test(line[prop])) { return false }\n\t      else { line[prop] += \" \" + cls }\n\t      return true\n\t    })\n\t  }),\n\t  removeLineClass: docMethodOp(function(handle, where, cls) {\n\t    return changeLine(this, handle, where == \"gutter\" ? \"gutter\" : \"class\", function (line) {\n\t      var prop = where == \"text\" ? \"textClass\"\n\t               : where == \"background\" ? \"bgClass\"\n\t               : where == \"gutter\" ? \"gutterClass\" : \"wrapClass\"\n\t      var cur = line[prop]\n\t      if (!cur) { return false }\n\t      else if (cls == null) { line[prop] = null }\n\t      else {\n\t        var found = cur.match(classTest(cls))\n\t        if (!found) { return false }\n\t        var end = found.index + found[0].length\n\t        line[prop] = cur.slice(0, found.index) + (!found.index || end == cur.length ? \"\" : \" \") + cur.slice(end) || null\n\t      }\n\t      return true\n\t    })\n\t  }),\n\t\n\t  addLineWidget: docMethodOp(function(handle, node, options) {\n\t    return addLineWidget(this, handle, node, options)\n\t  }),\n\t  removeLineWidget: function(widget) { widget.clear() },\n\t\n\t  markText: function(from, to, options) {\n\t    return markText(this, clipPos(this, from), clipPos(this, to), options, options && options.type || \"range\")\n\t  },\n\t  setBookmark: function(pos, options) {\n\t    var realOpts = {replacedWith: options && (options.nodeType == null ? options.widget : options),\n\t                    insertLeft: options && options.insertLeft,\n\t                    clearWhenEmpty: false, shared: options && options.shared,\n\t                    handleMouseEvents: options && options.handleMouseEvents}\n\t    pos = clipPos(this, pos)\n\t    return markText(this, pos, pos, realOpts, \"bookmark\")\n\t  },\n\t  findMarksAt: function(pos) {\n\t    pos = clipPos(this, pos)\n\t    var markers = [], spans = getLine(this, pos.line).markedSpans\n\t    if (spans) { for (var i = 0; i < spans.length; ++i) {\n\t      var span = spans[i]\n\t      if ((span.from == null || span.from <= pos.ch) &&\n\t          (span.to == null || span.to >= pos.ch))\n\t        { markers.push(span.marker.parent || span.marker) }\n\t    } }\n\t    return markers\n\t  },\n\t  findMarks: function(from, to, filter) {\n\t    from = clipPos(this, from); to = clipPos(this, to)\n\t    var found = [], lineNo = from.line\n\t    this.iter(from.line, to.line + 1, function (line) {\n\t      var spans = line.markedSpans\n\t      if (spans) { for (var i = 0; i < spans.length; i++) {\n\t        var span = spans[i]\n\t        if (!(span.to != null && lineNo == from.line && from.ch >= span.to ||\n\t              span.from == null && lineNo != from.line ||\n\t              span.from != null && lineNo == to.line && span.from >= to.ch) &&\n\t            (!filter || filter(span.marker)))\n\t          { found.push(span.marker.parent || span.marker) }\n\t      } }\n\t      ++lineNo\n\t    })\n\t    return found\n\t  },\n\t  getAllMarks: function() {\n\t    var markers = []\n\t    this.iter(function (line) {\n\t      var sps = line.markedSpans\n\t      if (sps) { for (var i = 0; i < sps.length; ++i)\n\t        { if (sps[i].from != null) { markers.push(sps[i].marker) } } }\n\t    })\n\t    return markers\n\t  },\n\t\n\t  posFromIndex: function(off) {\n\t    var ch, lineNo = this.first, sepSize = this.lineSeparator().length\n\t    this.iter(function (line) {\n\t      var sz = line.text.length + sepSize\n\t      if (sz > off) { ch = off; return true }\n\t      off -= sz\n\t      ++lineNo\n\t    })\n\t    return clipPos(this, Pos(lineNo, ch))\n\t  },\n\t  indexFromPos: function (coords) {\n\t    coords = clipPos(this, coords)\n\t    var index = coords.ch\n\t    if (coords.line < this.first || coords.ch < 0) { return 0 }\n\t    var sepSize = this.lineSeparator().length\n\t    this.iter(this.first, coords.line, function (line) { // iter aborts when callback returns a truthy value\n\t      index += line.text.length + sepSize\n\t    })\n\t    return index\n\t  },\n\t\n\t  copy: function(copyHistory) {\n\t    var doc = new Doc(getLines(this, this.first, this.first + this.size),\n\t                      this.modeOption, this.first, this.lineSep)\n\t    doc.scrollTop = this.scrollTop; doc.scrollLeft = this.scrollLeft\n\t    doc.sel = this.sel\n\t    doc.extend = false\n\t    if (copyHistory) {\n\t      doc.history.undoDepth = this.history.undoDepth\n\t      doc.setHistory(this.getHistory())\n\t    }\n\t    return doc\n\t  },\n\t\n\t  linkedDoc: function(options) {\n\t    if (!options) { options = {} }\n\t    var from = this.first, to = this.first + this.size\n\t    if (options.from != null && options.from > from) { from = options.from }\n\t    if (options.to != null && options.to < to) { to = options.to }\n\t    var copy = new Doc(getLines(this, from, to), options.mode || this.modeOption, from, this.lineSep)\n\t    if (options.sharedHist) { copy.history = this.history\n\t    ; }(this.linked || (this.linked = [])).push({doc: copy, sharedHist: options.sharedHist})\n\t    copy.linked = [{doc: this, isParent: true, sharedHist: options.sharedHist}]\n\t    copySharedMarkers(copy, findSharedMarkers(this))\n\t    return copy\n\t  },\n\t  unlinkDoc: function(other) {\n\t    var this$1 = this;\n\t\n\t    if (other instanceof CodeMirror) { other = other.doc }\n\t    if (this.linked) { for (var i = 0; i < this.linked.length; ++i) {\n\t      var link = this$1.linked[i]\n\t      if (link.doc != other) { continue }\n\t      this$1.linked.splice(i, 1)\n\t      other.unlinkDoc(this$1)\n\t      detachSharedMarkers(findSharedMarkers(this$1))\n\t      break\n\t    } }\n\t    // If the histories were shared, split them again\n\t    if (other.history == this.history) {\n\t      var splitIds = [other.id]\n\t      linkedDocs(other, function (doc) { return splitIds.push(doc.id); }, true)\n\t      other.history = new History(null)\n\t      other.history.done = copyHistoryArray(this.history.done, splitIds)\n\t      other.history.undone = copyHistoryArray(this.history.undone, splitIds)\n\t    }\n\t  },\n\t  iterLinkedDocs: function(f) {linkedDocs(this, f)},\n\t\n\t  getMode: function() {return this.mode},\n\t  getEditor: function() {return this.cm},\n\t\n\t  splitLines: function(str) {\n\t    if (this.lineSep) { return str.split(this.lineSep) }\n\t    return splitLinesAuto(str)\n\t  },\n\t  lineSeparator: function() { return this.lineSep || \"\\n\" }\n\t})\n\t\n\t// Public alias.\n\tDoc.prototype.eachLine = Doc.prototype.iter\n\t\n\t// Kludge to work around strange IE behavior where it'll sometimes\n\t// re-fire a series of drag-related events right after the drop (#1551)\n\tvar lastDrop = 0\n\t\n\tfunction onDrop(e) {\n\t  var cm = this\n\t  clearDragCursor(cm)\n\t  if (signalDOMEvent(cm, e) || eventInWidget(cm.display, e))\n\t    { return }\n\t  e_preventDefault(e)\n\t  if (ie) { lastDrop = +new Date }\n\t  var pos = posFromMouse(cm, e, true), files = e.dataTransfer.files\n\t  if (!pos || cm.isReadOnly()) { return }\n\t  // Might be a file drop, in which case we simply extract the text\n\t  // and insert it.\n\t  if (files && files.length && window.FileReader && window.File) {\n\t    var n = files.length, text = Array(n), read = 0\n\t    var loadFile = function (file, i) {\n\t      if (cm.options.allowDropFileTypes &&\n\t          indexOf(cm.options.allowDropFileTypes, file.type) == -1)\n\t        { return }\n\t\n\t      var reader = new FileReader\n\t      reader.onload = operation(cm, function () {\n\t        var content = reader.result\n\t        if (/[\\x00-\\x08\\x0e-\\x1f]{2}/.test(content)) { content = \"\" }\n\t        text[i] = content\n\t        if (++read == n) {\n\t          pos = clipPos(cm.doc, pos)\n\t          var change = {from: pos, to: pos,\n\t                        text: cm.doc.splitLines(text.join(cm.doc.lineSeparator())),\n\t                        origin: \"paste\"}\n\t          makeChange(cm.doc, change)\n\t          setSelectionReplaceHistory(cm.doc, simpleSelection(pos, changeEnd(change)))\n\t        }\n\t      })\n\t      reader.readAsText(file)\n\t    }\n\t    for (var i = 0; i < n; ++i) { loadFile(files[i], i) }\n\t  } else { // Normal drop\n\t    // Don't do a replace if the drop happened inside of the selected text.\n\t    if (cm.state.draggingText && cm.doc.sel.contains(pos) > -1) {\n\t      cm.state.draggingText(e)\n\t      // Ensure the editor is re-focused\n\t      setTimeout(function () { return cm.display.input.focus(); }, 20)\n\t      return\n\t    }\n\t    try {\n\t      var text$1 = e.dataTransfer.getData(\"Text\")\n\t      if (text$1) {\n\t        var selected\n\t        if (cm.state.draggingText && !cm.state.draggingText.copy)\n\t          { selected = cm.listSelections() }\n\t        setSelectionNoUndo(cm.doc, simpleSelection(pos, pos))\n\t        if (selected) { for (var i$1 = 0; i$1 < selected.length; ++i$1)\n\t          { replaceRange(cm.doc, \"\", selected[i$1].anchor, selected[i$1].head, \"drag\") } }\n\t        cm.replaceSelection(text$1, \"around\", \"paste\")\n\t        cm.display.input.focus()\n\t      }\n\t    }\n\t    catch(e){}\n\t  }\n\t}\n\t\n\tfunction onDragStart(cm, e) {\n\t  if (ie && (!cm.state.draggingText || +new Date - lastDrop < 100)) { e_stop(e); return }\n\t  if (signalDOMEvent(cm, e) || eventInWidget(cm.display, e)) { return }\n\t\n\t  e.dataTransfer.setData(\"Text\", cm.getSelection())\n\t  e.dataTransfer.effectAllowed = \"copyMove\"\n\t\n\t  // Use dummy image instead of default browsers image.\n\t  // Recent Safari (~6.0.2) have a tendency to segfault when this happens, so we don't do it there.\n\t  if (e.dataTransfer.setDragImage && !safari) {\n\t    var img = elt(\"img\", null, null, \"position: fixed; left: 0; top: 0;\")\n\t    img.src = \"data:image/gif;base64,R0lGODlhAQABAAAAACH5BAEKAAEALAAAAAABAAEAAAICTAEAOw==\"\n\t    if (presto) {\n\t      img.width = img.height = 1\n\t      cm.display.wrapper.appendChild(img)\n\t      // Force a relayout, or Opera won't use our image for some obscure reason\n\t      img._top = img.offsetTop\n\t    }\n\t    e.dataTransfer.setDragImage(img, 0, 0)\n\t    if (presto) { img.parentNode.removeChild(img) }\n\t  }\n\t}\n\t\n\tfunction onDragOver(cm, e) {\n\t  var pos = posFromMouse(cm, e)\n\t  if (!pos) { return }\n\t  var frag = document.createDocumentFragment()\n\t  drawSelectionCursor(cm, pos, frag)\n\t  if (!cm.display.dragCursor) {\n\t    cm.display.dragCursor = elt(\"div\", null, \"CodeMirror-cursors CodeMirror-dragcursors\")\n\t    cm.display.lineSpace.insertBefore(cm.display.dragCursor, cm.display.cursorDiv)\n\t  }\n\t  removeChildrenAndAdd(cm.display.dragCursor, frag)\n\t}\n\t\n\tfunction clearDragCursor(cm) {\n\t  if (cm.display.dragCursor) {\n\t    cm.display.lineSpace.removeChild(cm.display.dragCursor)\n\t    cm.display.dragCursor = null\n\t  }\n\t}\n\t\n\t// These must be handled carefully, because naively registering a\n\t// handler for each editor will cause the editors to never be\n\t// garbage collected.\n\t\n\tfunction forEachCodeMirror(f) {\n\t  if (!document.body.getElementsByClassName) { return }\n\t  var byClass = document.body.getElementsByClassName(\"CodeMirror\")\n\t  for (var i = 0; i < byClass.length; i++) {\n\t    var cm = byClass[i].CodeMirror\n\t    if (cm) { f(cm) }\n\t  }\n\t}\n\t\n\tvar globalsRegistered = false\n\tfunction ensureGlobalHandlers() {\n\t  if (globalsRegistered) { return }\n\t  registerGlobalHandlers()\n\t  globalsRegistered = true\n\t}\n\tfunction registerGlobalHandlers() {\n\t  // When the window resizes, we need to refresh active editors.\n\t  var resizeTimer\n\t  on(window, \"resize\", function () {\n\t    if (resizeTimer == null) { resizeTimer = setTimeout(function () {\n\t      resizeTimer = null\n\t      forEachCodeMirror(onResize)\n\t    }, 100) }\n\t  })\n\t  // When the window loses focus, we want to show the editor as blurred\n\t  on(window, \"blur\", function () { return forEachCodeMirror(onBlur); })\n\t}\n\t// Called when the window resizes\n\tfunction onResize(cm) {\n\t  var d = cm.display\n\t  if (d.lastWrapHeight == d.wrapper.clientHeight && d.lastWrapWidth == d.wrapper.clientWidth)\n\t    { return }\n\t  // Might be a text scaling operation, clear size caches.\n\t  d.cachedCharWidth = d.cachedTextHeight = d.cachedPaddingH = null\n\t  d.scrollbarsClipped = false\n\t  cm.setSize()\n\t}\n\t\n\tvar keyNames = {\n\t  3: \"Enter\", 8: \"Backspace\", 9: \"Tab\", 13: \"Enter\", 16: \"Shift\", 17: \"Ctrl\", 18: \"Alt\",\n\t  19: \"Pause\", 20: \"CapsLock\", 27: \"Esc\", 32: \"Space\", 33: \"PageUp\", 34: \"PageDown\", 35: \"End\",\n\t  36: \"Home\", 37: \"Left\", 38: \"Up\", 39: \"Right\", 40: \"Down\", 44: \"PrintScrn\", 45: \"Insert\",\n\t  46: \"Delete\", 59: \";\", 61: \"=\", 91: \"Mod\", 92: \"Mod\", 93: \"Mod\",\n\t  106: \"*\", 107: \"=\", 109: \"-\", 110: \".\", 111: \"/\", 127: \"Delete\",\n\t  173: \"-\", 186: \";\", 187: \"=\", 188: \",\", 189: \"-\", 190: \".\", 191: \"/\", 192: \"`\", 219: \"[\", 220: \"\\\\\",\n\t  221: \"]\", 222: \"'\", 63232: \"Up\", 63233: \"Down\", 63234: \"Left\", 63235: \"Right\", 63272: \"Delete\",\n\t  63273: \"Home\", 63275: \"End\", 63276: \"PageUp\", 63277: \"PageDown\", 63302: \"Insert\"\n\t}\n\t\n\t// Number keys\n\tfor (var i = 0; i < 10; i++) { keyNames[i + 48] = keyNames[i + 96] = String(i) }\n\t// Alphabetic keys\n\tfor (var i$1 = 65; i$1 <= 90; i$1++) { keyNames[i$1] = String.fromCharCode(i$1) }\n\t// Function keys\n\tfor (var i$2 = 1; i$2 <= 12; i$2++) { keyNames[i$2 + 111] = keyNames[i$2 + 63235] = \"F\" + i$2 }\n\t\n\tvar keyMap = {}\n\t\n\tkeyMap.basic = {\n\t  \"Left\": \"goCharLeft\", \"Right\": \"goCharRight\", \"Up\": \"goLineUp\", \"Down\": \"goLineDown\",\n\t  \"End\": \"goLineEnd\", \"Home\": \"goLineStartSmart\", \"PageUp\": \"goPageUp\", \"PageDown\": \"goPageDown\",\n\t  \"Delete\": \"delCharAfter\", \"Backspace\": \"delCharBefore\", \"Shift-Backspace\": \"delCharBefore\",\n\t  \"Tab\": \"defaultTab\", \"Shift-Tab\": \"indentAuto\",\n\t  \"Enter\": \"newlineAndIndent\", \"Insert\": \"toggleOverwrite\",\n\t  \"Esc\": \"singleSelection\"\n\t}\n\t// Note that the save and find-related commands aren't defined by\n\t// default. User code or addons can define them. Unknown commands\n\t// are simply ignored.\n\tkeyMap.pcDefault = {\n\t  \"Ctrl-A\": \"selectAll\", \"Ctrl-D\": \"deleteLine\", \"Ctrl-Z\": \"undo\", \"Shift-Ctrl-Z\": \"redo\", \"Ctrl-Y\": \"redo\",\n\t  \"Ctrl-Home\": \"goDocStart\", \"Ctrl-End\": \"goDocEnd\", \"Ctrl-Up\": \"goLineUp\", \"Ctrl-Down\": \"goLineDown\",\n\t  \"Ctrl-Left\": \"goGroupLeft\", \"Ctrl-Right\": \"goGroupRight\", \"Alt-Left\": \"goLineStart\", \"Alt-Right\": \"goLineEnd\",\n\t  \"Ctrl-Backspace\": \"delGroupBefore\", \"Ctrl-Delete\": \"delGroupAfter\", \"Ctrl-S\": \"save\", \"Ctrl-F\": \"find\",\n\t  \"Ctrl-G\": \"findNext\", \"Shift-Ctrl-G\": \"findPrev\", \"Shift-Ctrl-F\": \"replace\", \"Shift-Ctrl-R\": \"replaceAll\",\n\t  \"Ctrl-[\": \"indentLess\", \"Ctrl-]\": \"indentMore\",\n\t  \"Ctrl-U\": \"undoSelection\", \"Shift-Ctrl-U\": \"redoSelection\", \"Alt-U\": \"redoSelection\",\n\t  fallthrough: \"basic\"\n\t}\n\t// Very basic readline/emacs-style bindings, which are standard on Mac.\n\tkeyMap.emacsy = {\n\t  \"Ctrl-F\": \"goCharRight\", \"Ctrl-B\": \"goCharLeft\", \"Ctrl-P\": \"goLineUp\", \"Ctrl-N\": \"goLineDown\",\n\t  \"Alt-F\": \"goWordRight\", \"Alt-B\": \"goWordLeft\", \"Ctrl-A\": \"goLineStart\", \"Ctrl-E\": \"goLineEnd\",\n\t  \"Ctrl-V\": \"goPageDown\", \"Shift-Ctrl-V\": \"goPageUp\", \"Ctrl-D\": \"delCharAfter\", \"Ctrl-H\": \"delCharBefore\",\n\t  \"Alt-D\": \"delWordAfter\", \"Alt-Backspace\": \"delWordBefore\", \"Ctrl-K\": \"killLine\", \"Ctrl-T\": \"transposeChars\",\n\t  \"Ctrl-O\": \"openLine\"\n\t}\n\tkeyMap.macDefault = {\n\t  \"Cmd-A\": \"selectAll\", \"Cmd-D\": \"deleteLine\", \"Cmd-Z\": \"undo\", \"Shift-Cmd-Z\": \"redo\", \"Cmd-Y\": \"redo\",\n\t  \"Cmd-Home\": \"goDocStart\", \"Cmd-Up\": \"goDocStart\", \"Cmd-End\": \"goDocEnd\", \"Cmd-Down\": \"goDocEnd\", \"Alt-Left\": \"goGroupLeft\",\n\t  \"Alt-Right\": \"goGroupRight\", \"Cmd-Left\": \"goLineLeft\", \"Cmd-Right\": \"goLineRight\", \"Alt-Backspace\": \"delGroupBefore\",\n\t  \"Ctrl-Alt-Backspace\": \"delGroupAfter\", \"Alt-Delete\": \"delGroupAfter\", \"Cmd-S\": \"save\", \"Cmd-F\": \"find\",\n\t  \"Cmd-G\": \"findNext\", \"Shift-Cmd-G\": \"findPrev\", \"Cmd-Alt-F\": \"replace\", \"Shift-Cmd-Alt-F\": \"replaceAll\",\n\t  \"Cmd-[\": \"indentLess\", \"Cmd-]\": \"indentMore\", \"Cmd-Backspace\": \"delWrappedLineLeft\", \"Cmd-Delete\": \"delWrappedLineRight\",\n\t  \"Cmd-U\": \"undoSelection\", \"Shift-Cmd-U\": \"redoSelection\", \"Ctrl-Up\": \"goDocStart\", \"Ctrl-Down\": \"goDocEnd\",\n\t  fallthrough: [\"basic\", \"emacsy\"]\n\t}\n\tkeyMap[\"default\"] = mac ? keyMap.macDefault : keyMap.pcDefault\n\t\n\t// KEYMAP DISPATCH\n\t\n\tfunction normalizeKeyName(name) {\n\t  var parts = name.split(/-(?!$)/)\n\t  name = parts[parts.length - 1]\n\t  var alt, ctrl, shift, cmd\n\t  for (var i = 0; i < parts.length - 1; i++) {\n\t    var mod = parts[i]\n\t    if (/^(cmd|meta|m)$/i.test(mod)) { cmd = true }\n\t    else if (/^a(lt)?$/i.test(mod)) { alt = true }\n\t    else if (/^(c|ctrl|control)$/i.test(mod)) { ctrl = true }\n\t    else if (/^s(hift)?$/i.test(mod)) { shift = true }\n\t    else { throw new Error(\"Unrecognized modifier name: \" + mod) }\n\t  }\n\t  if (alt) { name = \"Alt-\" + name }\n\t  if (ctrl) { name = \"Ctrl-\" + name }\n\t  if (cmd) { name = \"Cmd-\" + name }\n\t  if (shift) { name = \"Shift-\" + name }\n\t  return name\n\t}\n\t\n\t// This is a kludge to keep keymaps mostly working as raw objects\n\t// (backwards compatibility) while at the same time support features\n\t// like normalization and multi-stroke key bindings. It compiles a\n\t// new normalized keymap, and then updates the old object to reflect\n\t// this.\n\tfunction normalizeKeyMap(keymap) {\n\t  var copy = {}\n\t  for (var keyname in keymap) { if (keymap.hasOwnProperty(keyname)) {\n\t    var value = keymap[keyname]\n\t    if (/^(name|fallthrough|(de|at)tach)$/.test(keyname)) { continue }\n\t    if (value == \"...\") { delete keymap[keyname]; continue }\n\t\n\t    var keys = map(keyname.split(\" \"), normalizeKeyName)\n\t    for (var i = 0; i < keys.length; i++) {\n\t      var val = (void 0), name = (void 0)\n\t      if (i == keys.length - 1) {\n\t        name = keys.join(\" \")\n\t        val = value\n\t      } else {\n\t        name = keys.slice(0, i + 1).join(\" \")\n\t        val = \"...\"\n\t      }\n\t      var prev = copy[name]\n\t      if (!prev) { copy[name] = val }\n\t      else if (prev != val) { throw new Error(\"Inconsistent bindings for \" + name) }\n\t    }\n\t    delete keymap[keyname]\n\t  } }\n\t  for (var prop in copy) { keymap[prop] = copy[prop] }\n\t  return keymap\n\t}\n\t\n\tfunction lookupKey(key, map, handle, context) {\n\t  map = getKeyMap(map)\n\t  var found = map.call ? map.call(key, context) : map[key]\n\t  if (found === false) { return \"nothing\" }\n\t  if (found === \"...\") { return \"multi\" }\n\t  if (found != null && handle(found)) { return \"handled\" }\n\t\n\t  if (map.fallthrough) {\n\t    if (Object.prototype.toString.call(map.fallthrough) != \"[object Array]\")\n\t      { return lookupKey(key, map.fallthrough, handle, context) }\n\t    for (var i = 0; i < map.fallthrough.length; i++) {\n\t      var result = lookupKey(key, map.fallthrough[i], handle, context)\n\t      if (result) { return result }\n\t    }\n\t  }\n\t}\n\t\n\t// Modifier key presses don't count as 'real' key presses for the\n\t// purpose of keymap fallthrough.\n\tfunction isModifierKey(value) {\n\t  var name = typeof value == \"string\" ? value : keyNames[value.keyCode]\n\t  return name == \"Ctrl\" || name == \"Alt\" || name == \"Shift\" || name == \"Mod\"\n\t}\n\t\n\t// Look up the name of a key as indicated by an event object.\n\tfunction keyName(event, noShift) {\n\t  if (presto && event.keyCode == 34 && event[\"char\"]) { return false }\n\t  var base = keyNames[event.keyCode], name = base\n\t  if (name == null || event.altGraphKey) { return false }\n\t  if (event.altKey && base != \"Alt\") { name = \"Alt-\" + name }\n\t  if ((flipCtrlCmd ? event.metaKey : event.ctrlKey) && base != \"Ctrl\") { name = \"Ctrl-\" + name }\n\t  if ((flipCtrlCmd ? event.ctrlKey : event.metaKey) && base != \"Cmd\") { name = \"Cmd-\" + name }\n\t  if (!noShift && event.shiftKey && base != \"Shift\") { name = \"Shift-\" + name }\n\t  return name\n\t}\n\t\n\tfunction getKeyMap(val) {\n\t  return typeof val == \"string\" ? keyMap[val] : val\n\t}\n\t\n\t// Helper for deleting text near the selection(s), used to implement\n\t// backspace, delete, and similar functionality.\n\tfunction deleteNearSelection(cm, compute) {\n\t  var ranges = cm.doc.sel.ranges, kill = []\n\t  // Build up a set of ranges to kill first, merging overlapping\n\t  // ranges.\n\t  for (var i = 0; i < ranges.length; i++) {\n\t    var toKill = compute(ranges[i])\n\t    while (kill.length && cmp(toKill.from, lst(kill).to) <= 0) {\n\t      var replaced = kill.pop()\n\t      if (cmp(replaced.from, toKill.from) < 0) {\n\t        toKill.from = replaced.from\n\t        break\n\t      }\n\t    }\n\t    kill.push(toKill)\n\t  }\n\t  // Next, remove those actual ranges.\n\t  runInOp(cm, function () {\n\t    for (var i = kill.length - 1; i >= 0; i--)\n\t      { replaceRange(cm.doc, \"\", kill[i].from, kill[i].to, \"+delete\") }\n\t    ensureCursorVisible(cm)\n\t  })\n\t}\n\t\n\t// Commands are parameter-less actions that can be performed on an\n\t// editor, mostly used for keybindings.\n\tvar commands = {\n\t  selectAll: selectAll,\n\t  singleSelection: function (cm) { return cm.setSelection(cm.getCursor(\"anchor\"), cm.getCursor(\"head\"), sel_dontScroll); },\n\t  killLine: function (cm) { return deleteNearSelection(cm, function (range) {\n\t    if (range.empty()) {\n\t      var len = getLine(cm.doc, range.head.line).text.length\n\t      if (range.head.ch == len && range.head.line < cm.lastLine())\n\t        { return {from: range.head, to: Pos(range.head.line + 1, 0)} }\n\t      else\n\t        { return {from: range.head, to: Pos(range.head.line, len)} }\n\t    } else {\n\t      return {from: range.from(), to: range.to()}\n\t    }\n\t  }); },\n\t  deleteLine: function (cm) { return deleteNearSelection(cm, function (range) { return ({\n\t    from: Pos(range.from().line, 0),\n\t    to: clipPos(cm.doc, Pos(range.to().line + 1, 0))\n\t  }); }); },\n\t  delLineLeft: function (cm) { return deleteNearSelection(cm, function (range) { return ({\n\t    from: Pos(range.from().line, 0), to: range.from()\n\t  }); }); },\n\t  delWrappedLineLeft: function (cm) { return deleteNearSelection(cm, function (range) {\n\t    var top = cm.charCoords(range.head, \"div\").top + 5\n\t    var leftPos = cm.coordsChar({left: 0, top: top}, \"div\")\n\t    return {from: leftPos, to: range.from()}\n\t  }); },\n\t  delWrappedLineRight: function (cm) { return deleteNearSelection(cm, function (range) {\n\t    var top = cm.charCoords(range.head, \"div\").top + 5\n\t    var rightPos = cm.coordsChar({left: cm.display.lineDiv.offsetWidth + 100, top: top}, \"div\")\n\t    return {from: range.from(), to: rightPos }\n\t  }); },\n\t  undo: function (cm) { return cm.undo(); },\n\t  redo: function (cm) { return cm.redo(); },\n\t  undoSelection: function (cm) { return cm.undoSelection(); },\n\t  redoSelection: function (cm) { return cm.redoSelection(); },\n\t  goDocStart: function (cm) { return cm.extendSelection(Pos(cm.firstLine(), 0)); },\n\t  goDocEnd: function (cm) { return cm.extendSelection(Pos(cm.lastLine())); },\n\t  goLineStart: function (cm) { return cm.extendSelectionsBy(function (range) { return lineStart(cm, range.head.line); },\n\t    {origin: \"+move\", bias: 1}\n\t  ); },\n\t  goLineStartSmart: function (cm) { return cm.extendSelectionsBy(function (range) { return lineStartSmart(cm, range.head); },\n\t    {origin: \"+move\", bias: 1}\n\t  ); },\n\t  goLineEnd: function (cm) { return cm.extendSelectionsBy(function (range) { return lineEnd(cm, range.head.line); },\n\t    {origin: \"+move\", bias: -1}\n\t  ); },\n\t  goLineRight: function (cm) { return cm.extendSelectionsBy(function (range) {\n\t    var top = cm.charCoords(range.head, \"div\").top + 5\n\t    return cm.coordsChar({left: cm.display.lineDiv.offsetWidth + 100, top: top}, \"div\")\n\t  }, sel_move); },\n\t  goLineLeft: function (cm) { return cm.extendSelectionsBy(function (range) {\n\t    var top = cm.charCoords(range.head, \"div\").top + 5\n\t    return cm.coordsChar({left: 0, top: top}, \"div\")\n\t  }, sel_move); },\n\t  goLineLeftSmart: function (cm) { return cm.extendSelectionsBy(function (range) {\n\t    var top = cm.charCoords(range.head, \"div\").top + 5\n\t    var pos = cm.coordsChar({left: 0, top: top}, \"div\")\n\t    if (pos.ch < cm.getLine(pos.line).search(/\\S/)) { return lineStartSmart(cm, range.head) }\n\t    return pos\n\t  }, sel_move); },\n\t  goLineUp: function (cm) { return cm.moveV(-1, \"line\"); },\n\t  goLineDown: function (cm) { return cm.moveV(1, \"line\"); },\n\t  goPageUp: function (cm) { return cm.moveV(-1, \"page\"); },\n\t  goPageDown: function (cm) { return cm.moveV(1, \"page\"); },\n\t  goCharLeft: function (cm) { return cm.moveH(-1, \"char\"); },\n\t  goCharRight: function (cm) { return cm.moveH(1, \"char\"); },\n\t  goColumnLeft: function (cm) { return cm.moveH(-1, \"column\"); },\n\t  goColumnRight: function (cm) { return cm.moveH(1, \"column\"); },\n\t  goWordLeft: function (cm) { return cm.moveH(-1, \"word\"); },\n\t  goGroupRight: function (cm) { return cm.moveH(1, \"group\"); },\n\t  goGroupLeft: function (cm) { return cm.moveH(-1, \"group\"); },\n\t  goWordRight: function (cm) { return cm.moveH(1, \"word\"); },\n\t  delCharBefore: function (cm) { return cm.deleteH(-1, \"char\"); },\n\t  delCharAfter: function (cm) { return cm.deleteH(1, \"char\"); },\n\t  delWordBefore: function (cm) { return cm.deleteH(-1, \"word\"); },\n\t  delWordAfter: function (cm) { return cm.deleteH(1, \"word\"); },\n\t  delGroupBefore: function (cm) { return cm.deleteH(-1, \"group\"); },\n\t  delGroupAfter: function (cm) { return cm.deleteH(1, \"group\"); },\n\t  indentAuto: function (cm) { return cm.indentSelection(\"smart\"); },\n\t  indentMore: function (cm) { return cm.indentSelection(\"add\"); },\n\t  indentLess: function (cm) { return cm.indentSelection(\"subtract\"); },\n\t  insertTab: function (cm) { return cm.replaceSelection(\"\\t\"); },\n\t  insertSoftTab: function (cm) {\n\t    var spaces = [], ranges = cm.listSelections(), tabSize = cm.options.tabSize\n\t    for (var i = 0; i < ranges.length; i++) {\n\t      var pos = ranges[i].from()\n\t      var col = countColumn(cm.getLine(pos.line), pos.ch, tabSize)\n\t      spaces.push(spaceStr(tabSize - col % tabSize))\n\t    }\n\t    cm.replaceSelections(spaces)\n\t  },\n\t  defaultTab: function (cm) {\n\t    if (cm.somethingSelected()) { cm.indentSelection(\"add\") }\n\t    else { cm.execCommand(\"insertTab\") }\n\t  },\n\t  // Swap the two chars left and right of each selection's head.\n\t  // Move cursor behind the two swapped characters afterwards.\n\t  //\n\t  // Doesn't consider line feeds a character.\n\t  // Doesn't scan more than one line above to find a character.\n\t  // Doesn't do anything on an empty line.\n\t  // Doesn't do anything with non-empty selections.\n\t  transposeChars: function (cm) { return runInOp(cm, function () {\n\t    var ranges = cm.listSelections(), newSel = []\n\t    for (var i = 0; i < ranges.length; i++) {\n\t      if (!ranges[i].empty()) { continue }\n\t      var cur = ranges[i].head, line = getLine(cm.doc, cur.line).text\n\t      if (line) {\n\t        if (cur.ch == line.length) { cur = new Pos(cur.line, cur.ch - 1) }\n\t        if (cur.ch > 0) {\n\t          cur = new Pos(cur.line, cur.ch + 1)\n\t          cm.replaceRange(line.charAt(cur.ch - 1) + line.charAt(cur.ch - 2),\n\t                          Pos(cur.line, cur.ch - 2), cur, \"+transpose\")\n\t        } else if (cur.line > cm.doc.first) {\n\t          var prev = getLine(cm.doc, cur.line - 1).text\n\t          if (prev) {\n\t            cur = new Pos(cur.line, 1)\n\t            cm.replaceRange(line.charAt(0) + cm.doc.lineSeparator() +\n\t                            prev.charAt(prev.length - 1),\n\t                            Pos(cur.line - 1, prev.length - 1), cur, \"+transpose\")\n\t          }\n\t        }\n\t      }\n\t      newSel.push(new Range(cur, cur))\n\t    }\n\t    cm.setSelections(newSel)\n\t  }); },\n\t  newlineAndIndent: function (cm) { return runInOp(cm, function () {\n\t    var sels = cm.listSelections()\n\t    for (var i = sels.length - 1; i >= 0; i--)\n\t      { cm.replaceRange(cm.doc.lineSeparator(), sels[i].anchor, sels[i].head, \"+input\") }\n\t    sels = cm.listSelections()\n\t    for (var i$1 = 0; i$1 < sels.length; i$1++)\n\t      { cm.indentLine(sels[i$1].from().line, null, true) }\n\t    ensureCursorVisible(cm)\n\t  }); },\n\t  openLine: function (cm) { return cm.replaceSelection(\"\\n\", \"start\"); },\n\t  toggleOverwrite: function (cm) { return cm.toggleOverwrite(); }\n\t}\n\t\n\t\n\tfunction lineStart(cm, lineN) {\n\t  var line = getLine(cm.doc, lineN)\n\t  var visual = visualLine(line)\n\t  if (visual != line) { lineN = lineNo(visual) }\n\t  return endOfLine(true, cm, visual, lineN, 1)\n\t}\n\tfunction lineEnd(cm, lineN) {\n\t  var line = getLine(cm.doc, lineN)\n\t  var visual = visualLineEnd(line)\n\t  if (visual != line) { lineN = lineNo(visual) }\n\t  return endOfLine(true, cm, line, lineN, -1)\n\t}\n\tfunction lineStartSmart(cm, pos) {\n\t  var start = lineStart(cm, pos.line)\n\t  var line = getLine(cm.doc, start.line)\n\t  var order = getOrder(line)\n\t  if (!order || order[0].level == 0) {\n\t    var firstNonWS = Math.max(0, line.text.search(/\\S/))\n\t    var inWS = pos.line == start.line && pos.ch <= firstNonWS && pos.ch\n\t    return Pos(start.line, inWS ? 0 : firstNonWS, start.sticky)\n\t  }\n\t  return start\n\t}\n\t\n\t// Run a handler that was bound to a key.\n\tfunction doHandleBinding(cm, bound, dropShift) {\n\t  if (typeof bound == \"string\") {\n\t    bound = commands[bound]\n\t    if (!bound) { return false }\n\t  }\n\t  // Ensure previous input has been read, so that the handler sees a\n\t  // consistent view of the document\n\t  cm.display.input.ensurePolled()\n\t  var prevShift = cm.display.shift, done = false\n\t  try {\n\t    if (cm.isReadOnly()) { cm.state.suppressEdits = true }\n\t    if (dropShift) { cm.display.shift = false }\n\t    done = bound(cm) != Pass\n\t  } finally {\n\t    cm.display.shift = prevShift\n\t    cm.state.suppressEdits = false\n\t  }\n\t  return done\n\t}\n\t\n\tfunction lookupKeyForEditor(cm, name, handle) {\n\t  for (var i = 0; i < cm.state.keyMaps.length; i++) {\n\t    var result = lookupKey(name, cm.state.keyMaps[i], handle, cm)\n\t    if (result) { return result }\n\t  }\n\t  return (cm.options.extraKeys && lookupKey(name, cm.options.extraKeys, handle, cm))\n\t    || lookupKey(name, cm.options.keyMap, handle, cm)\n\t}\n\t\n\tvar stopSeq = new Delayed\n\tfunction dispatchKey(cm, name, e, handle) {\n\t  var seq = cm.state.keySeq\n\t  if (seq) {\n\t    if (isModifierKey(name)) { return \"handled\" }\n\t    stopSeq.set(50, function () {\n\t      if (cm.state.keySeq == seq) {\n\t        cm.state.keySeq = null\n\t        cm.display.input.reset()\n\t      }\n\t    })\n\t    name = seq + \" \" + name\n\t  }\n\t  var result = lookupKeyForEditor(cm, name, handle)\n\t\n\t  if (result == \"multi\")\n\t    { cm.state.keySeq = name }\n\t  if (result == \"handled\")\n\t    { signalLater(cm, \"keyHandled\", cm, name, e) }\n\t\n\t  if (result == \"handled\" || result == \"multi\") {\n\t    e_preventDefault(e)\n\t    restartBlink(cm)\n\t  }\n\t\n\t  if (seq && !result && /\\'$/.test(name)) {\n\t    e_preventDefault(e)\n\t    return true\n\t  }\n\t  return !!result\n\t}\n\t\n\t// Handle a key from the keydown event.\n\tfunction handleKeyBinding(cm, e) {\n\t  var name = keyName(e, true)\n\t  if (!name) { return false }\n\t\n\t  if (e.shiftKey && !cm.state.keySeq) {\n\t    // First try to resolve full name (including 'Shift-'). Failing\n\t    // that, see if there is a cursor-motion command (starting with\n\t    // 'go') bound to the keyname without 'Shift-'.\n\t    return dispatchKey(cm, \"Shift-\" + name, e, function (b) { return doHandleBinding(cm, b, true); })\n\t        || dispatchKey(cm, name, e, function (b) {\n\t             if (typeof b == \"string\" ? /^go[A-Z]/.test(b) : b.motion)\n\t               { return doHandleBinding(cm, b) }\n\t           })\n\t  } else {\n\t    return dispatchKey(cm, name, e, function (b) { return doHandleBinding(cm, b); })\n\t  }\n\t}\n\t\n\t// Handle a key from the keypress event\n\tfunction handleCharBinding(cm, e, ch) {\n\t  return dispatchKey(cm, \"'\" + ch + \"'\", e, function (b) { return doHandleBinding(cm, b, true); })\n\t}\n\t\n\tvar lastStoppedKey = null\n\tfunction onKeyDown(e) {\n\t  var cm = this\n\t  cm.curOp.focus = activeElt()\n\t  if (signalDOMEvent(cm, e)) { return }\n\t  // IE does strange things with escape.\n\t  if (ie && ie_version < 11 && e.keyCode == 27) { e.returnValue = false }\n\t  var code = e.keyCode\n\t  cm.display.shift = code == 16 || e.shiftKey\n\t  var handled = handleKeyBinding(cm, e)\n\t  if (presto) {\n\t    lastStoppedKey = handled ? code : null\n\t    // Opera has no cut event... we try to at least catch the key combo\n\t    if (!handled && code == 88 && !hasCopyEvent && (mac ? e.metaKey : e.ctrlKey))\n\t      { cm.replaceSelection(\"\", null, \"cut\") }\n\t  }\n\t\n\t  // Turn mouse into crosshair when Alt is held on Mac.\n\t  if (code == 18 && !/\\bCodeMirror-crosshair\\b/.test(cm.display.lineDiv.className))\n\t    { showCrossHair(cm) }\n\t}\n\t\n\tfunction showCrossHair(cm) {\n\t  var lineDiv = cm.display.lineDiv\n\t  addClass(lineDiv, \"CodeMirror-crosshair\")\n\t\n\t  function up(e) {\n\t    if (e.keyCode == 18 || !e.altKey) {\n\t      rmClass(lineDiv, \"CodeMirror-crosshair\")\n\t      off(document, \"keyup\", up)\n\t      off(document, \"mouseover\", up)\n\t    }\n\t  }\n\t  on(document, \"keyup\", up)\n\t  on(document, \"mouseover\", up)\n\t}\n\t\n\tfunction onKeyUp(e) {\n\t  if (e.keyCode == 16) { this.doc.sel.shift = false }\n\t  signalDOMEvent(this, e)\n\t}\n\t\n\tfunction onKeyPress(e) {\n\t  var cm = this\n\t  if (eventInWidget(cm.display, e) || signalDOMEvent(cm, e) || e.ctrlKey && !e.altKey || mac && e.metaKey) { return }\n\t  var keyCode = e.keyCode, charCode = e.charCode\n\t  if (presto && keyCode == lastStoppedKey) {lastStoppedKey = null; e_preventDefault(e); return}\n\t  if ((presto && (!e.which || e.which < 10)) && handleKeyBinding(cm, e)) { return }\n\t  var ch = String.fromCharCode(charCode == null ? keyCode : charCode)\n\t  // Some browsers fire keypress events for backspace\n\t  if (ch == \"\\x08\") { return }\n\t  if (handleCharBinding(cm, e, ch)) { return }\n\t  cm.display.input.onKeyPress(e)\n\t}\n\t\n\t// A mouse down can be a single click, double click, triple click,\n\t// start of selection drag, start of text drag, new cursor\n\t// (ctrl-click), rectangle drag (alt-drag), or xwin\n\t// middle-click-paste. Or it might be a click on something we should\n\t// not interfere with, such as a scrollbar or widget.\n\tfunction onMouseDown(e) {\n\t  var cm = this, display = cm.display\n\t  if (signalDOMEvent(cm, e) || display.activeTouch && display.input.supportsTouch()) { return }\n\t  display.input.ensurePolled()\n\t  display.shift = e.shiftKey\n\t\n\t  if (eventInWidget(display, e)) {\n\t    if (!webkit) {\n\t      // Briefly turn off draggability, to allow widgets to do\n\t      // normal dragging things.\n\t      display.scroller.draggable = false\n\t      setTimeout(function () { return display.scroller.draggable = true; }, 100)\n\t    }\n\t    return\n\t  }\n\t  if (clickInGutter(cm, e)) { return }\n\t  var start = posFromMouse(cm, e)\n\t  window.focus()\n\t\n\t  switch (e_button(e)) {\n\t  case 1:\n\t    // #3261: make sure, that we're not starting a second selection\n\t    if (cm.state.selectingText)\n\t      { cm.state.selectingText(e) }\n\t    else if (start)\n\t      { leftButtonDown(cm, e, start) }\n\t    else if (e_target(e) == display.scroller)\n\t      { e_preventDefault(e) }\n\t    break\n\t  case 2:\n\t    if (webkit) { cm.state.lastMiddleDown = +new Date }\n\t    if (start) { extendSelection(cm.doc, start) }\n\t    setTimeout(function () { return display.input.focus(); }, 20)\n\t    e_preventDefault(e)\n\t    break\n\t  case 3:\n\t    if (captureRightClick) { onContextMenu(cm, e) }\n\t    else { delayBlurEvent(cm) }\n\t    break\n\t  }\n\t}\n\t\n\tvar lastClick;\n\tvar lastDoubleClick;\n\tfunction leftButtonDown(cm, e, start) {\n\t  if (ie) { setTimeout(bind(ensureFocus, cm), 0) }\n\t  else { cm.curOp.focus = activeElt() }\n\t\n\t  var now = +new Date, type\n\t  if (lastDoubleClick && lastDoubleClick.time > now - 400 && cmp(lastDoubleClick.pos, start) == 0) {\n\t    type = \"triple\"\n\t  } else if (lastClick && lastClick.time > now - 400 && cmp(lastClick.pos, start) == 0) {\n\t    type = \"double\"\n\t    lastDoubleClick = {time: now, pos: start}\n\t  } else {\n\t    type = \"single\"\n\t    lastClick = {time: now, pos: start}\n\t  }\n\t\n\t  var sel = cm.doc.sel, modifier = mac ? e.metaKey : e.ctrlKey, contained\n\t  if (cm.options.dragDrop && dragAndDrop && !cm.isReadOnly() &&\n\t      type == \"single\" && (contained = sel.contains(start)) > -1 &&\n\t      (cmp((contained = sel.ranges[contained]).from(), start) < 0 || start.xRel > 0) &&\n\t      (cmp(contained.to(), start) > 0 || start.xRel < 0))\n\t    { leftButtonStartDrag(cm, e, start, modifier) }\n\t  else\n\t    { leftButtonSelect(cm, e, start, type, modifier) }\n\t}\n\t\n\t// Start a text drag. When it ends, see if any dragging actually\n\t// happen, and treat as a click if it didn't.\n\tfunction leftButtonStartDrag(cm, e, start, modifier) {\n\t  var display = cm.display, startTime = +new Date\n\t  var dragEnd = operation(cm, function (e2) {\n\t    if (webkit) { display.scroller.draggable = false }\n\t    cm.state.draggingText = false\n\t    off(document, \"mouseup\", dragEnd)\n\t    off(display.scroller, \"drop\", dragEnd)\n\t    if (Math.abs(e.clientX - e2.clientX) + Math.abs(e.clientY - e2.clientY) < 10) {\n\t      e_preventDefault(e2)\n\t      if (!modifier && +new Date - 200 < startTime)\n\t        { extendSelection(cm.doc, start) }\n\t      // Work around unexplainable focus problem in IE9 (#2127) and Chrome (#3081)\n\t      if (webkit || ie && ie_version == 9)\n\t        { setTimeout(function () {document.body.focus(); display.input.focus()}, 20) }\n\t      else\n\t        { display.input.focus() }\n\t    }\n\t  })\n\t  // Let the drag handler handle this.\n\t  if (webkit) { display.scroller.draggable = true }\n\t  cm.state.draggingText = dragEnd\n\t  dragEnd.copy = mac ? e.altKey : e.ctrlKey\n\t  // IE's approach to draggable\n\t  if (display.scroller.dragDrop) { display.scroller.dragDrop() }\n\t  on(document, \"mouseup\", dragEnd)\n\t  on(display.scroller, \"drop\", dragEnd)\n\t}\n\t\n\t// Normal selection, as opposed to text dragging.\n\tfunction leftButtonSelect(cm, e, start, type, addNew) {\n\t  var display = cm.display, doc = cm.doc\n\t  e_preventDefault(e)\n\t\n\t  var ourRange, ourIndex, startSel = doc.sel, ranges = startSel.ranges\n\t  if (addNew && !e.shiftKey) {\n\t    ourIndex = doc.sel.contains(start)\n\t    if (ourIndex > -1)\n\t      { ourRange = ranges[ourIndex] }\n\t    else\n\t      { ourRange = new Range(start, start) }\n\t  } else {\n\t    ourRange = doc.sel.primary()\n\t    ourIndex = doc.sel.primIndex\n\t  }\n\t\n\t  if (chromeOS ? e.shiftKey && e.metaKey : e.altKey) {\n\t    type = \"rect\"\n\t    if (!addNew) { ourRange = new Range(start, start) }\n\t    start = posFromMouse(cm, e, true, true)\n\t    ourIndex = -1\n\t  } else if (type == \"double\") {\n\t    var word = cm.findWordAt(start)\n\t    if (cm.display.shift || doc.extend)\n\t      { ourRange = extendRange(doc, ourRange, word.anchor, word.head) }\n\t    else\n\t      { ourRange = word }\n\t  } else if (type == \"triple\") {\n\t    var line = new Range(Pos(start.line, 0), clipPos(doc, Pos(start.line + 1, 0)))\n\t    if (cm.display.shift || doc.extend)\n\t      { ourRange = extendRange(doc, ourRange, line.anchor, line.head) }\n\t    else\n\t      { ourRange = line }\n\t  } else {\n\t    ourRange = extendRange(doc, ourRange, start)\n\t  }\n\t\n\t  if (!addNew) {\n\t    ourIndex = 0\n\t    setSelection(doc, new Selection([ourRange], 0), sel_mouse)\n\t    startSel = doc.sel\n\t  } else if (ourIndex == -1) {\n\t    ourIndex = ranges.length\n\t    setSelection(doc, normalizeSelection(ranges.concat([ourRange]), ourIndex),\n\t                 {scroll: false, origin: \"*mouse\"})\n\t  } else if (ranges.length > 1 && ranges[ourIndex].empty() && type == \"single\" && !e.shiftKey) {\n\t    setSelection(doc, normalizeSelection(ranges.slice(0, ourIndex).concat(ranges.slice(ourIndex + 1)), 0),\n\t                 {scroll: false, origin: \"*mouse\"})\n\t    startSel = doc.sel\n\t  } else {\n\t    replaceOneSelection(doc, ourIndex, ourRange, sel_mouse)\n\t  }\n\t\n\t  var lastPos = start\n\t  function extendTo(pos) {\n\t    if (cmp(lastPos, pos) == 0) { return }\n\t    lastPos = pos\n\t\n\t    if (type == \"rect\") {\n\t      var ranges = [], tabSize = cm.options.tabSize\n\t      var startCol = countColumn(getLine(doc, start.line).text, start.ch, tabSize)\n\t      var posCol = countColumn(getLine(doc, pos.line).text, pos.ch, tabSize)\n\t      var left = Math.min(startCol, posCol), right = Math.max(startCol, posCol)\n\t      for (var line = Math.min(start.line, pos.line), end = Math.min(cm.lastLine(), Math.max(start.line, pos.line));\n\t           line <= end; line++) {\n\t        var text = getLine(doc, line).text, leftPos = findColumn(text, left, tabSize)\n\t        if (left == right)\n\t          { ranges.push(new Range(Pos(line, leftPos), Pos(line, leftPos))) }\n\t        else if (text.length > leftPos)\n\t          { ranges.push(new Range(Pos(line, leftPos), Pos(line, findColumn(text, right, tabSize)))) }\n\t      }\n\t      if (!ranges.length) { ranges.push(new Range(start, start)) }\n\t      setSelection(doc, normalizeSelection(startSel.ranges.slice(0, ourIndex).concat(ranges), ourIndex),\n\t                   {origin: \"*mouse\", scroll: false})\n\t      cm.scrollIntoView(pos)\n\t    } else {\n\t      var oldRange = ourRange\n\t      var anchor = oldRange.anchor, head = pos\n\t      if (type != \"single\") {\n\t        var range\n\t        if (type == \"double\")\n\t          { range = cm.findWordAt(pos) }\n\t        else\n\t          { range = new Range(Pos(pos.line, 0), clipPos(doc, Pos(pos.line + 1, 0))) }\n\t        if (cmp(range.anchor, anchor) > 0) {\n\t          head = range.head\n\t          anchor = minPos(oldRange.from(), range.anchor)\n\t        } else {\n\t          head = range.anchor\n\t          anchor = maxPos(oldRange.to(), range.head)\n\t        }\n\t      }\n\t      var ranges$1 = startSel.ranges.slice(0)\n\t      ranges$1[ourIndex] = new Range(clipPos(doc, anchor), head)\n\t      setSelection(doc, normalizeSelection(ranges$1, ourIndex), sel_mouse)\n\t    }\n\t  }\n\t\n\t  var editorSize = display.wrapper.getBoundingClientRect()\n\t  // Used to ensure timeout re-tries don't fire when another extend\n\t  // happened in the meantime (clearTimeout isn't reliable -- at\n\t  // least on Chrome, the timeouts still happen even when cleared,\n\t  // if the clear happens after their scheduled firing time).\n\t  var counter = 0\n\t\n\t  function extend(e) {\n\t    var curCount = ++counter\n\t    var cur = posFromMouse(cm, e, true, type == \"rect\")\n\t    if (!cur) { return }\n\t    if (cmp(cur, lastPos) != 0) {\n\t      cm.curOp.focus = activeElt()\n\t      extendTo(cur)\n\t      var visible = visibleLines(display, doc)\n\t      if (cur.line >= visible.to || cur.line < visible.from)\n\t        { setTimeout(operation(cm, function () {if (counter == curCount) { extend(e) }}), 150) }\n\t    } else {\n\t      var outside = e.clientY < editorSize.top ? -20 : e.clientY > editorSize.bottom ? 20 : 0\n\t      if (outside) { setTimeout(operation(cm, function () {\n\t        if (counter != curCount) { return }\n\t        display.scroller.scrollTop += outside\n\t        extend(e)\n\t      }), 50) }\n\t    }\n\t  }\n\t\n\t  function done(e) {\n\t    cm.state.selectingText = false\n\t    counter = Infinity\n\t    e_preventDefault(e)\n\t    display.input.focus()\n\t    off(document, \"mousemove\", move)\n\t    off(document, \"mouseup\", up)\n\t    doc.history.lastSelOrigin = null\n\t  }\n\t\n\t  var move = operation(cm, function (e) {\n\t    if (!e_button(e)) { done(e) }\n\t    else { extend(e) }\n\t  })\n\t  var up = operation(cm, done)\n\t  cm.state.selectingText = up\n\t  on(document, \"mousemove\", move)\n\t  on(document, \"mouseup\", up)\n\t}\n\t\n\t\n\t// Determines whether an event happened in the gutter, and fires the\n\t// handlers for the corresponding event.\n\tfunction gutterEvent(cm, e, type, prevent) {\n\t  var mX, mY\n\t  try { mX = e.clientX; mY = e.clientY }\n\t  catch(e) { return false }\n\t  if (mX >= Math.floor(cm.display.gutters.getBoundingClientRect().right)) { return false }\n\t  if (prevent) { e_preventDefault(e) }\n\t\n\t  var display = cm.display\n\t  var lineBox = display.lineDiv.getBoundingClientRect()\n\t\n\t  if (mY > lineBox.bottom || !hasHandler(cm, type)) { return e_defaultPrevented(e) }\n\t  mY -= lineBox.top - display.viewOffset\n\t\n\t  for (var i = 0; i < cm.options.gutters.length; ++i) {\n\t    var g = display.gutters.childNodes[i]\n\t    if (g && g.getBoundingClientRect().right >= mX) {\n\t      var line = lineAtHeight(cm.doc, mY)\n\t      var gutter = cm.options.gutters[i]\n\t      signal(cm, type, cm, line, gutter, e)\n\t      return e_defaultPrevented(e)\n\t    }\n\t  }\n\t}\n\t\n\tfunction clickInGutter(cm, e) {\n\t  return gutterEvent(cm, e, \"gutterClick\", true)\n\t}\n\t\n\t// CONTEXT MENU HANDLING\n\t\n\t// To make the context menu work, we need to briefly unhide the\n\t// textarea (making it as unobtrusive as possible) to let the\n\t// right-click take effect on it.\n\tfunction onContextMenu(cm, e) {\n\t  if (eventInWidget(cm.display, e) || contextMenuInGutter(cm, e)) { return }\n\t  if (signalDOMEvent(cm, e, \"contextmenu\")) { return }\n\t  cm.display.input.onContextMenu(e)\n\t}\n\t\n\tfunction contextMenuInGutter(cm, e) {\n\t  if (!hasHandler(cm, \"gutterContextMenu\")) { return false }\n\t  return gutterEvent(cm, e, \"gutterContextMenu\", false)\n\t}\n\t\n\tfunction themeChanged(cm) {\n\t  cm.display.wrapper.className = cm.display.wrapper.className.replace(/\\s*cm-s-\\S+/g, \"\") +\n\t    cm.options.theme.replace(/(^|\\s)\\s*/g, \" cm-s-\")\n\t  clearCaches(cm)\n\t}\n\t\n\tvar Init = {toString: function(){return \"CodeMirror.Init\"}}\n\t\n\tvar defaults = {}\n\tvar optionHandlers = {}\n\t\n\tfunction defineOptions(CodeMirror) {\n\t  var optionHandlers = CodeMirror.optionHandlers\n\t\n\t  function option(name, deflt, handle, notOnInit) {\n\t    CodeMirror.defaults[name] = deflt\n\t    if (handle) { optionHandlers[name] =\n\t      notOnInit ? function (cm, val, old) {if (old != Init) { handle(cm, val, old) }} : handle }\n\t  }\n\t\n\t  CodeMirror.defineOption = option\n\t\n\t  // Passed to option handlers when there is no old value.\n\t  CodeMirror.Init = Init\n\t\n\t  // These two are, on init, called from the constructor because they\n\t  // have to be initialized before the editor can start at all.\n\t  option(\"value\", \"\", function (cm, val) { return cm.setValue(val); }, true)\n\t  option(\"mode\", null, function (cm, val) {\n\t    cm.doc.modeOption = val\n\t    loadMode(cm)\n\t  }, true)\n\t\n\t  option(\"indentUnit\", 2, loadMode, true)\n\t  option(\"indentWithTabs\", false)\n\t  option(\"smartIndent\", true)\n\t  option(\"tabSize\", 4, function (cm) {\n\t    resetModeState(cm)\n\t    clearCaches(cm)\n\t    regChange(cm)\n\t  }, true)\n\t  option(\"lineSeparator\", null, function (cm, val) {\n\t    cm.doc.lineSep = val\n\t    if (!val) { return }\n\t    var newBreaks = [], lineNo = cm.doc.first\n\t    cm.doc.iter(function (line) {\n\t      for (var pos = 0;;) {\n\t        var found = line.text.indexOf(val, pos)\n\t        if (found == -1) { break }\n\t        pos = found + val.length\n\t        newBreaks.push(Pos(lineNo, found))\n\t      }\n\t      lineNo++\n\t    })\n\t    for (var i = newBreaks.length - 1; i >= 0; i--)\n\t      { replaceRange(cm.doc, val, newBreaks[i], Pos(newBreaks[i].line, newBreaks[i].ch + val.length)) }\n\t  })\n\t  option(\"specialChars\", /[\\u0000-\\u001f\\u007f\\u00ad\\u061c\\u200b-\\u200f\\u2028\\u2029\\ufeff]/g, function (cm, val, old) {\n\t    cm.state.specialChars = new RegExp(val.source + (val.test(\"\\t\") ? \"\" : \"|\\t\"), \"g\")\n\t    if (old != Init) { cm.refresh() }\n\t  })\n\t  option(\"specialCharPlaceholder\", defaultSpecialCharPlaceholder, function (cm) { return cm.refresh(); }, true)\n\t  option(\"electricChars\", true)\n\t  option(\"inputStyle\", mobile ? \"contenteditable\" : \"textarea\", function () {\n\t    throw new Error(\"inputStyle can not (yet) be changed in a running editor\") // FIXME\n\t  }, true)\n\t  option(\"spellcheck\", false, function (cm, val) { return cm.getInputField().spellcheck = val; }, true)\n\t  option(\"rtlMoveVisually\", !windows)\n\t  option(\"wholeLineUpdateBefore\", true)\n\t\n\t  option(\"theme\", \"default\", function (cm) {\n\t    themeChanged(cm)\n\t    guttersChanged(cm)\n\t  }, true)\n\t  option(\"keyMap\", \"default\", function (cm, val, old) {\n\t    var next = getKeyMap(val)\n\t    var prev = old != Init && getKeyMap(old)\n\t    if (prev && prev.detach) { prev.detach(cm, next) }\n\t    if (next.attach) { next.attach(cm, prev || null) }\n\t  })\n\t  option(\"extraKeys\", null)\n\t\n\t  option(\"lineWrapping\", false, wrappingChanged, true)\n\t  option(\"gutters\", [], function (cm) {\n\t    setGuttersForLineNumbers(cm.options)\n\t    guttersChanged(cm)\n\t  }, true)\n\t  option(\"fixedGutter\", true, function (cm, val) {\n\t    cm.display.gutters.style.left = val ? compensateForHScroll(cm.display) + \"px\" : \"0\"\n\t    cm.refresh()\n\t  }, true)\n\t  option(\"coverGutterNextToScrollbar\", false, function (cm) { return updateScrollbars(cm); }, true)\n\t  option(\"scrollbarStyle\", \"native\", function (cm) {\n\t    initScrollbars(cm)\n\t    updateScrollbars(cm)\n\t    cm.display.scrollbars.setScrollTop(cm.doc.scrollTop)\n\t    cm.display.scrollbars.setScrollLeft(cm.doc.scrollLeft)\n\t  }, true)\n\t  option(\"lineNumbers\", false, function (cm) {\n\t    setGuttersForLineNumbers(cm.options)\n\t    guttersChanged(cm)\n\t  }, true)\n\t  option(\"firstLineNumber\", 1, guttersChanged, true)\n\t  option(\"lineNumberFormatter\", function (integer) { return integer; }, guttersChanged, true)\n\t  option(\"showCursorWhenSelecting\", false, updateSelection, true)\n\t\n\t  option(\"resetSelectionOnContextMenu\", true)\n\t  option(\"lineWiseCopyCut\", true)\n\t\n\t  option(\"readOnly\", false, function (cm, val) {\n\t    if (val == \"nocursor\") {\n\t      onBlur(cm)\n\t      cm.display.input.blur()\n\t      cm.display.disabled = true\n\t    } else {\n\t      cm.display.disabled = false\n\t    }\n\t    cm.display.input.readOnlyChanged(val)\n\t  })\n\t  option(\"disableInput\", false, function (cm, val) {if (!val) { cm.display.input.reset() }}, true)\n\t  option(\"dragDrop\", true, dragDropChanged)\n\t  option(\"allowDropFileTypes\", null)\n\t\n\t  option(\"cursorBlinkRate\", 530)\n\t  option(\"cursorScrollMargin\", 0)\n\t  option(\"cursorHeight\", 1, updateSelection, true)\n\t  option(\"singleCursorHeightPerLine\", true, updateSelection, true)\n\t  option(\"workTime\", 100)\n\t  option(\"workDelay\", 100)\n\t  option(\"flattenSpans\", true, resetModeState, true)\n\t  option(\"addModeClass\", false, resetModeState, true)\n\t  option(\"pollInterval\", 100)\n\t  option(\"undoDepth\", 200, function (cm, val) { return cm.doc.history.undoDepth = val; })\n\t  option(\"historyEventDelay\", 1250)\n\t  option(\"viewportMargin\", 10, function (cm) { return cm.refresh(); }, true)\n\t  option(\"maxHighlightLength\", 10000, resetModeState, true)\n\t  option(\"moveInputWithCursor\", true, function (cm, val) {\n\t    if (!val) { cm.display.input.resetPosition() }\n\t  })\n\t\n\t  option(\"tabindex\", null, function (cm, val) { return cm.display.input.getField().tabIndex = val || \"\"; })\n\t  option(\"autofocus\", null)\n\t}\n\t\n\tfunction guttersChanged(cm) {\n\t  updateGutters(cm)\n\t  regChange(cm)\n\t  alignHorizontally(cm)\n\t}\n\t\n\tfunction dragDropChanged(cm, value, old) {\n\t  var wasOn = old && old != Init\n\t  if (!value != !wasOn) {\n\t    var funcs = cm.display.dragFunctions\n\t    var toggle = value ? on : off\n\t    toggle(cm.display.scroller, \"dragstart\", funcs.start)\n\t    toggle(cm.display.scroller, \"dragenter\", funcs.enter)\n\t    toggle(cm.display.scroller, \"dragover\", funcs.over)\n\t    toggle(cm.display.scroller, \"dragleave\", funcs.leave)\n\t    toggle(cm.display.scroller, \"drop\", funcs.drop)\n\t  }\n\t}\n\t\n\tfunction wrappingChanged(cm) {\n\t  if (cm.options.lineWrapping) {\n\t    addClass(cm.display.wrapper, \"CodeMirror-wrap\")\n\t    cm.display.sizer.style.minWidth = \"\"\n\t    cm.display.sizerWidth = null\n\t  } else {\n\t    rmClass(cm.display.wrapper, \"CodeMirror-wrap\")\n\t    findMaxLine(cm)\n\t  }\n\t  estimateLineHeights(cm)\n\t  regChange(cm)\n\t  clearCaches(cm)\n\t  setTimeout(function () { return updateScrollbars(cm); }, 100)\n\t}\n\t\n\t// A CodeMirror instance represents an editor. This is the object\n\t// that user code is usually dealing with.\n\t\n\tfunction CodeMirror(place, options) {\n\t  var this$1 = this;\n\t\n\t  if (!(this instanceof CodeMirror)) { return new CodeMirror(place, options) }\n\t\n\t  this.options = options = options ? copyObj(options) : {}\n\t  // Determine effective options based on given values and defaults.\n\t  copyObj(defaults, options, false)\n\t  setGuttersForLineNumbers(options)\n\t\n\t  var doc = options.value\n\t  if (typeof doc == \"string\") { doc = new Doc(doc, options.mode, null, options.lineSeparator) }\n\t  this.doc = doc\n\t\n\t  var input = new CodeMirror.inputStyles[options.inputStyle](this)\n\t  var display = this.display = new Display(place, doc, input)\n\t  display.wrapper.CodeMirror = this\n\t  updateGutters(this)\n\t  themeChanged(this)\n\t  if (options.lineWrapping)\n\t    { this.display.wrapper.className += \" CodeMirror-wrap\" }\n\t  initScrollbars(this)\n\t\n\t  this.state = {\n\t    keyMaps: [],  // stores maps added by addKeyMap\n\t    overlays: [], // highlighting overlays, as added by addOverlay\n\t    modeGen: 0,   // bumped when mode/overlay changes, used to invalidate highlighting info\n\t    overwrite: false,\n\t    delayingBlurEvent: false,\n\t    focused: false,\n\t    suppressEdits: false, // used to disable editing during key handlers when in readOnly mode\n\t    pasteIncoming: false, cutIncoming: false, // help recognize paste/cut edits in input.poll\n\t    selectingText: false,\n\t    draggingText: false,\n\t    highlight: new Delayed(), // stores highlight worker timeout\n\t    keySeq: null,  // Unfinished key sequence\n\t    specialChars: null\n\t  }\n\t\n\t  if (options.autofocus && !mobile) { display.input.focus() }\n\t\n\t  // Override magic textarea content restore that IE sometimes does\n\t  // on our hidden textarea on reload\n\t  if (ie && ie_version < 11) { setTimeout(function () { return this$1.display.input.reset(true); }, 20) }\n\t\n\t  registerEventHandlers(this)\n\t  ensureGlobalHandlers()\n\t\n\t  startOperation(this)\n\t  this.curOp.forceUpdate = true\n\t  attachDoc(this, doc)\n\t\n\t  if ((options.autofocus && !mobile) || this.hasFocus())\n\t    { setTimeout(bind(onFocus, this), 20) }\n\t  else\n\t    { onBlur(this) }\n\t\n\t  for (var opt in optionHandlers) { if (optionHandlers.hasOwnProperty(opt))\n\t    { optionHandlers[opt](this$1, options[opt], Init) } }\n\t  maybeUpdateLineNumberWidth(this)\n\t  if (options.finishInit) { options.finishInit(this) }\n\t  for (var i = 0; i < initHooks.length; ++i) { initHooks[i](this$1) }\n\t  endOperation(this)\n\t  // Suppress optimizelegibility in Webkit, since it breaks text\n\t  // measuring on line wrapping boundaries.\n\t  if (webkit && options.lineWrapping &&\n\t      getComputedStyle(display.lineDiv).textRendering == \"optimizelegibility\")\n\t    { display.lineDiv.style.textRendering = \"auto\" }\n\t}\n\t\n\t// The default configuration options.\n\tCodeMirror.defaults = defaults\n\t// Functions to run when options are changed.\n\tCodeMirror.optionHandlers = optionHandlers\n\t\n\t// Attach the necessary event handlers when initializing the editor\n\tfunction registerEventHandlers(cm) {\n\t  var d = cm.display\n\t  on(d.scroller, \"mousedown\", operation(cm, onMouseDown))\n\t  // Older IE's will not fire a second mousedown for a double click\n\t  if (ie && ie_version < 11)\n\t    { on(d.scroller, \"dblclick\", operation(cm, function (e) {\n\t      if (signalDOMEvent(cm, e)) { return }\n\t      var pos = posFromMouse(cm, e)\n\t      if (!pos || clickInGutter(cm, e) || eventInWidget(cm.display, e)) { return }\n\t      e_preventDefault(e)\n\t      var word = cm.findWordAt(pos)\n\t      extendSelection(cm.doc, word.anchor, word.head)\n\t    })) }\n\t  else\n\t    { on(d.scroller, \"dblclick\", function (e) { return signalDOMEvent(cm, e) || e_preventDefault(e); }) }\n\t  // Some browsers fire contextmenu *after* opening the menu, at\n\t  // which point we can't mess with it anymore. Context menu is\n\t  // handled in onMouseDown for these browsers.\n\t  if (!captureRightClick) { on(d.scroller, \"contextmenu\", function (e) { return onContextMenu(cm, e); }) }\n\t\n\t  // Used to suppress mouse event handling when a touch happens\n\t  var touchFinished, prevTouch = {end: 0}\n\t  function finishTouch() {\n\t    if (d.activeTouch) {\n\t      touchFinished = setTimeout(function () { return d.activeTouch = null; }, 1000)\n\t      prevTouch = d.activeTouch\n\t      prevTouch.end = +new Date\n\t    }\n\t  }\n\t  function isMouseLikeTouchEvent(e) {\n\t    if (e.touches.length != 1) { return false }\n\t    var touch = e.touches[0]\n\t    return touch.radiusX <= 1 && touch.radiusY <= 1\n\t  }\n\t  function farAway(touch, other) {\n\t    if (other.left == null) { return true }\n\t    var dx = other.left - touch.left, dy = other.top - touch.top\n\t    return dx * dx + dy * dy > 20 * 20\n\t  }\n\t  on(d.scroller, \"touchstart\", function (e) {\n\t    if (!signalDOMEvent(cm, e) && !isMouseLikeTouchEvent(e)) {\n\t      d.input.ensurePolled()\n\t      clearTimeout(touchFinished)\n\t      var now = +new Date\n\t      d.activeTouch = {start: now, moved: false,\n\t                       prev: now - prevTouch.end <= 300 ? prevTouch : null}\n\t      if (e.touches.length == 1) {\n\t        d.activeTouch.left = e.touches[0].pageX\n\t        d.activeTouch.top = e.touches[0].pageY\n\t      }\n\t    }\n\t  })\n\t  on(d.scroller, \"touchmove\", function () {\n\t    if (d.activeTouch) { d.activeTouch.moved = true }\n\t  })\n\t  on(d.scroller, \"touchend\", function (e) {\n\t    var touch = d.activeTouch\n\t    if (touch && !eventInWidget(d, e) && touch.left != null &&\n\t        !touch.moved && new Date - touch.start < 300) {\n\t      var pos = cm.coordsChar(d.activeTouch, \"page\"), range\n\t      if (!touch.prev || farAway(touch, touch.prev)) // Single tap\n\t        { range = new Range(pos, pos) }\n\t      else if (!touch.prev.prev || farAway(touch, touch.prev.prev)) // Double tap\n\t        { range = cm.findWordAt(pos) }\n\t      else // Triple tap\n\t        { range = new Range(Pos(pos.line, 0), clipPos(cm.doc, Pos(pos.line + 1, 0))) }\n\t      cm.setSelection(range.anchor, range.head)\n\t      cm.focus()\n\t      e_preventDefault(e)\n\t    }\n\t    finishTouch()\n\t  })\n\t  on(d.scroller, \"touchcancel\", finishTouch)\n\t\n\t  // Sync scrolling between fake scrollbars and real scrollable\n\t  // area, ensure viewport is updated when scrolling.\n\t  on(d.scroller, \"scroll\", function () {\n\t    if (d.scroller.clientHeight) {\n\t      setScrollTop(cm, d.scroller.scrollTop)\n\t      setScrollLeft(cm, d.scroller.scrollLeft, true)\n\t      signal(cm, \"scroll\", cm)\n\t    }\n\t  })\n\t\n\t  // Listen to wheel events in order to try and update the viewport on time.\n\t  on(d.scroller, \"mousewheel\", function (e) { return onScrollWheel(cm, e); })\n\t  on(d.scroller, \"DOMMouseScroll\", function (e) { return onScrollWheel(cm, e); })\n\t\n\t  // Prevent wrapper from ever scrolling\n\t  on(d.wrapper, \"scroll\", function () { return d.wrapper.scrollTop = d.wrapper.scrollLeft = 0; })\n\t\n\t  d.dragFunctions = {\n\t    enter: function (e) {if (!signalDOMEvent(cm, e)) { e_stop(e) }},\n\t    over: function (e) {if (!signalDOMEvent(cm, e)) { onDragOver(cm, e); e_stop(e) }},\n\t    start: function (e) { return onDragStart(cm, e); },\n\t    drop: operation(cm, onDrop),\n\t    leave: function (e) {if (!signalDOMEvent(cm, e)) { clearDragCursor(cm) }}\n\t  }\n\t\n\t  var inp = d.input.getField()\n\t  on(inp, \"keyup\", function (e) { return onKeyUp.call(cm, e); })\n\t  on(inp, \"keydown\", operation(cm, onKeyDown))\n\t  on(inp, \"keypress\", operation(cm, onKeyPress))\n\t  on(inp, \"focus\", function (e) { return onFocus(cm, e); })\n\t  on(inp, \"blur\", function (e) { return onBlur(cm, e); })\n\t}\n\t\n\tvar initHooks = []\n\tCodeMirror.defineInitHook = function (f) { return initHooks.push(f); }\n\t\n\t// Indent the given line. The how parameter can be \"smart\",\n\t// \"add\"/null, \"subtract\", or \"prev\". When aggressive is false\n\t// (typically set to true for forced single-line indents), empty\n\t// lines are not indented, and places where the mode returns Pass\n\t// are left alone.\n\tfunction indentLine(cm, n, how, aggressive) {\n\t  var doc = cm.doc, state\n\t  if (how == null) { how = \"add\" }\n\t  if (how == \"smart\") {\n\t    // Fall back to \"prev\" when the mode doesn't have an indentation\n\t    // method.\n\t    if (!doc.mode.indent) { how = \"prev\" }\n\t    else { state = getStateBefore(cm, n) }\n\t  }\n\t\n\t  var tabSize = cm.options.tabSize\n\t  var line = getLine(doc, n), curSpace = countColumn(line.text, null, tabSize)\n\t  if (line.stateAfter) { line.stateAfter = null }\n\t  var curSpaceString = line.text.match(/^\\s*/)[0], indentation\n\t  if (!aggressive && !/\\S/.test(line.text)) {\n\t    indentation = 0\n\t    how = \"not\"\n\t  } else if (how == \"smart\") {\n\t    indentation = doc.mode.indent(state, line.text.slice(curSpaceString.length), line.text)\n\t    if (indentation == Pass || indentation > 150) {\n\t      if (!aggressive) { return }\n\t      how = \"prev\"\n\t    }\n\t  }\n\t  if (how == \"prev\") {\n\t    if (n > doc.first) { indentation = countColumn(getLine(doc, n-1).text, null, tabSize) }\n\t    else { indentation = 0 }\n\t  } else if (how == \"add\") {\n\t    indentation = curSpace + cm.options.indentUnit\n\t  } else if (how == \"subtract\") {\n\t    indentation = curSpace - cm.options.indentUnit\n\t  } else if (typeof how == \"number\") {\n\t    indentation = curSpace + how\n\t  }\n\t  indentation = Math.max(0, indentation)\n\t\n\t  var indentString = \"\", pos = 0\n\t  if (cm.options.indentWithTabs)\n\t    { for (var i = Math.floor(indentation / tabSize); i; --i) {pos += tabSize; indentString += \"\\t\"} }\n\t  if (pos < indentation) { indentString += spaceStr(indentation - pos) }\n\t\n\t  if (indentString != curSpaceString) {\n\t    replaceRange(doc, indentString, Pos(n, 0), Pos(n, curSpaceString.length), \"+input\")\n\t    line.stateAfter = null\n\t    return true\n\t  } else {\n\t    // Ensure that, if the cursor was in the whitespace at the start\n\t    // of the line, it is moved to the end of that space.\n\t    for (var i$1 = 0; i$1 < doc.sel.ranges.length; i$1++) {\n\t      var range = doc.sel.ranges[i$1]\n\t      if (range.head.line == n && range.head.ch < curSpaceString.length) {\n\t        var pos$1 = Pos(n, curSpaceString.length)\n\t        replaceOneSelection(doc, i$1, new Range(pos$1, pos$1))\n\t        break\n\t      }\n\t    }\n\t  }\n\t}\n\t\n\t// This will be set to a {lineWise: bool, text: [string]} object, so\n\t// that, when pasting, we know what kind of selections the copied\n\t// text was made out of.\n\tvar lastCopied = null\n\t\n\tfunction setLastCopied(newLastCopied) {\n\t  lastCopied = newLastCopied\n\t}\n\t\n\tfunction applyTextInput(cm, inserted, deleted, sel, origin) {\n\t  var doc = cm.doc\n\t  cm.display.shift = false\n\t  if (!sel) { sel = doc.sel }\n\t\n\t  var paste = cm.state.pasteIncoming || origin == \"paste\"\n\t  var textLines = splitLinesAuto(inserted), multiPaste = null\n\t  // When pasing N lines into N selections, insert one line per selection\n\t  if (paste && sel.ranges.length > 1) {\n\t    if (lastCopied && lastCopied.text.join(\"\\n\") == inserted) {\n\t      if (sel.ranges.length % lastCopied.text.length == 0) {\n\t        multiPaste = []\n\t        for (var i = 0; i < lastCopied.text.length; i++)\n\t          { multiPaste.push(doc.splitLines(lastCopied.text[i])) }\n\t      }\n\t    } else if (textLines.length == sel.ranges.length) {\n\t      multiPaste = map(textLines, function (l) { return [l]; })\n\t    }\n\t  }\n\t\n\t  var updateInput\n\t  // Normal behavior is to insert the new text into every selection\n\t  for (var i$1 = sel.ranges.length - 1; i$1 >= 0; i$1--) {\n\t    var range = sel.ranges[i$1]\n\t    var from = range.from(), to = range.to()\n\t    if (range.empty()) {\n\t      if (deleted && deleted > 0) // Handle deletion\n\t        { from = Pos(from.line, from.ch - deleted) }\n\t      else if (cm.state.overwrite && !paste) // Handle overwrite\n\t        { to = Pos(to.line, Math.min(getLine(doc, to.line).text.length, to.ch + lst(textLines).length)) }\n\t      else if (lastCopied && lastCopied.lineWise && lastCopied.text.join(\"\\n\") == inserted)\n\t        { from = to = Pos(from.line, 0) }\n\t    }\n\t    updateInput = cm.curOp.updateInput\n\t    var changeEvent = {from: from, to: to, text: multiPaste ? multiPaste[i$1 % multiPaste.length] : textLines,\n\t                       origin: origin || (paste ? \"paste\" : cm.state.cutIncoming ? \"cut\" : \"+input\")}\n\t    makeChange(cm.doc, changeEvent)\n\t    signalLater(cm, \"inputRead\", cm, changeEvent)\n\t  }\n\t  if (inserted && !paste)\n\t    { triggerElectric(cm, inserted) }\n\t\n\t  ensureCursorVisible(cm)\n\t  cm.curOp.updateInput = updateInput\n\t  cm.curOp.typing = true\n\t  cm.state.pasteIncoming = cm.state.cutIncoming = false\n\t}\n\t\n\tfunction handlePaste(e, cm) {\n\t  var pasted = e.clipboardData && e.clipboardData.getData(\"Text\")\n\t  if (pasted) {\n\t    e.preventDefault()\n\t    if (!cm.isReadOnly() && !cm.options.disableInput)\n\t      { runInOp(cm, function () { return applyTextInput(cm, pasted, 0, null, \"paste\"); }) }\n\t    return true\n\t  }\n\t}\n\t\n\tfunction triggerElectric(cm, inserted) {\n\t  // When an 'electric' character is inserted, immediately trigger a reindent\n\t  if (!cm.options.electricChars || !cm.options.smartIndent) { return }\n\t  var sel = cm.doc.sel\n\t\n\t  for (var i = sel.ranges.length - 1; i >= 0; i--) {\n\t    var range = sel.ranges[i]\n\t    if (range.head.ch > 100 || (i && sel.ranges[i - 1].head.line == range.head.line)) { continue }\n\t    var mode = cm.getModeAt(range.head)\n\t    var indented = false\n\t    if (mode.electricChars) {\n\t      for (var j = 0; j < mode.electricChars.length; j++)\n\t        { if (inserted.indexOf(mode.electricChars.charAt(j)) > -1) {\n\t          indented = indentLine(cm, range.head.line, \"smart\")\n\t          break\n\t        } }\n\t    } else if (mode.electricInput) {\n\t      if (mode.electricInput.test(getLine(cm.doc, range.head.line).text.slice(0, range.head.ch)))\n\t        { indented = indentLine(cm, range.head.line, \"smart\") }\n\t    }\n\t    if (indented) { signalLater(cm, \"electricInput\", cm, range.head.line) }\n\t  }\n\t}\n\t\n\tfunction copyableRanges(cm) {\n\t  var text = [], ranges = []\n\t  for (var i = 0; i < cm.doc.sel.ranges.length; i++) {\n\t    var line = cm.doc.sel.ranges[i].head.line\n\t    var lineRange = {anchor: Pos(line, 0), head: Pos(line + 1, 0)}\n\t    ranges.push(lineRange)\n\t    text.push(cm.getRange(lineRange.anchor, lineRange.head))\n\t  }\n\t  return {text: text, ranges: ranges}\n\t}\n\t\n\tfunction disableBrowserMagic(field, spellcheck) {\n\t  field.setAttribute(\"autocorrect\", \"off\")\n\t  field.setAttribute(\"autocapitalize\", \"off\")\n\t  field.setAttribute(\"spellcheck\", !!spellcheck)\n\t}\n\t\n\tfunction hiddenTextarea() {\n\t  var te = elt(\"textarea\", null, null, \"position: absolute; bottom: -1em; padding: 0; width: 1px; height: 1em; outline: none\")\n\t  var div = elt(\"div\", [te], null, \"overflow: hidden; position: relative; width: 3px; height: 0px;\")\n\t  // The textarea is kept positioned near the cursor to prevent the\n\t  // fact that it'll be scrolled into view on input from scrolling\n\t  // our fake cursor out of view. On webkit, when wrap=off, paste is\n\t  // very slow. So make the area wide instead.\n\t  if (webkit) { te.style.width = \"1000px\" }\n\t  else { te.setAttribute(\"wrap\", \"off\") }\n\t  // If border: 0; -- iOS fails to open keyboard (issue #1287)\n\t  if (ios) { te.style.border = \"1px solid black\" }\n\t  disableBrowserMagic(te)\n\t  return div\n\t}\n\t\n\t// The publicly visible API. Note that methodOp(f) means\n\t// 'wrap f in an operation, performed on its `this` parameter'.\n\t\n\t// This is not the complete set of editor methods. Most of the\n\t// methods defined on the Doc type are also injected into\n\t// CodeMirror.prototype, for backwards compatibility and\n\t// convenience.\n\t\n\tfunction addEditorMethods(CodeMirror) {\n\t  var optionHandlers = CodeMirror.optionHandlers\n\t\n\t  var helpers = CodeMirror.helpers = {}\n\t\n\t  CodeMirror.prototype = {\n\t    constructor: CodeMirror,\n\t    focus: function(){window.focus(); this.display.input.focus()},\n\t\n\t    setOption: function(option, value) {\n\t      var options = this.options, old = options[option]\n\t      if (options[option] == value && option != \"mode\") { return }\n\t      options[option] = value\n\t      if (optionHandlers.hasOwnProperty(option))\n\t        { operation(this, optionHandlers[option])(this, value, old) }\n\t      signal(this, \"optionChange\", this, option)\n\t    },\n\t\n\t    getOption: function(option) {return this.options[option]},\n\t    getDoc: function() {return this.doc},\n\t\n\t    addKeyMap: function(map, bottom) {\n\t      this.state.keyMaps[bottom ? \"push\" : \"unshift\"](getKeyMap(map))\n\t    },\n\t    removeKeyMap: function(map) {\n\t      var maps = this.state.keyMaps\n\t      for (var i = 0; i < maps.length; ++i)\n\t        { if (maps[i] == map || maps[i].name == map) {\n\t          maps.splice(i, 1)\n\t          return true\n\t        } }\n\t    },\n\t\n\t    addOverlay: methodOp(function(spec, options) {\n\t      var mode = spec.token ? spec : CodeMirror.getMode(this.options, spec)\n\t      if (mode.startState) { throw new Error(\"Overlays may not be stateful.\") }\n\t      insertSorted(this.state.overlays,\n\t                   {mode: mode, modeSpec: spec, opaque: options && options.opaque,\n\t                    priority: (options && options.priority) || 0},\n\t                   function (overlay) { return overlay.priority; })\n\t      this.state.modeGen++\n\t      regChange(this)\n\t    }),\n\t    removeOverlay: methodOp(function(spec) {\n\t      var this$1 = this;\n\t\n\t      var overlays = this.state.overlays\n\t      for (var i = 0; i < overlays.length; ++i) {\n\t        var cur = overlays[i].modeSpec\n\t        if (cur == spec || typeof spec == \"string\" && cur.name == spec) {\n\t          overlays.splice(i, 1)\n\t          this$1.state.modeGen++\n\t          regChange(this$1)\n\t          return\n\t        }\n\t      }\n\t    }),\n\t\n\t    indentLine: methodOp(function(n, dir, aggressive) {\n\t      if (typeof dir != \"string\" && typeof dir != \"number\") {\n\t        if (dir == null) { dir = this.options.smartIndent ? \"smart\" : \"prev\" }\n\t        else { dir = dir ? \"add\" : \"subtract\" }\n\t      }\n\t      if (isLine(this.doc, n)) { indentLine(this, n, dir, aggressive) }\n\t    }),\n\t    indentSelection: methodOp(function(how) {\n\t      var this$1 = this;\n\t\n\t      var ranges = this.doc.sel.ranges, end = -1\n\t      for (var i = 0; i < ranges.length; i++) {\n\t        var range = ranges[i]\n\t        if (!range.empty()) {\n\t          var from = range.from(), to = range.to()\n\t          var start = Math.max(end, from.line)\n\t          end = Math.min(this$1.lastLine(), to.line - (to.ch ? 0 : 1)) + 1\n\t          for (var j = start; j < end; ++j)\n\t            { indentLine(this$1, j, how) }\n\t          var newRanges = this$1.doc.sel.ranges\n\t          if (from.ch == 0 && ranges.length == newRanges.length && newRanges[i].from().ch > 0)\n\t            { replaceOneSelection(this$1.doc, i, new Range(from, newRanges[i].to()), sel_dontScroll) }\n\t        } else if (range.head.line > end) {\n\t          indentLine(this$1, range.head.line, how, true)\n\t          end = range.head.line\n\t          if (i == this$1.doc.sel.primIndex) { ensureCursorVisible(this$1) }\n\t        }\n\t      }\n\t    }),\n\t\n\t    // Fetch the parser token for a given character. Useful for hacks\n\t    // that want to inspect the mode state (say, for completion).\n\t    getTokenAt: function(pos, precise) {\n\t      return takeToken(this, pos, precise)\n\t    },\n\t\n\t    getLineTokens: function(line, precise) {\n\t      return takeToken(this, Pos(line), precise, true)\n\t    },\n\t\n\t    getTokenTypeAt: function(pos) {\n\t      pos = clipPos(this.doc, pos)\n\t      var styles = getLineStyles(this, getLine(this.doc, pos.line))\n\t      var before = 0, after = (styles.length - 1) / 2, ch = pos.ch\n\t      var type\n\t      if (ch == 0) { type = styles[2] }\n\t      else { for (;;) {\n\t        var mid = (before + after) >> 1\n\t        if ((mid ? styles[mid * 2 - 1] : 0) >= ch) { after = mid }\n\t        else if (styles[mid * 2 + 1] < ch) { before = mid + 1 }\n\t        else { type = styles[mid * 2 + 2]; break }\n\t      } }\n\t      var cut = type ? type.indexOf(\"overlay \") : -1\n\t      return cut < 0 ? type : cut == 0 ? null : type.slice(0, cut - 1)\n\t    },\n\t\n\t    getModeAt: function(pos) {\n\t      var mode = this.doc.mode\n\t      if (!mode.innerMode) { return mode }\n\t      return CodeMirror.innerMode(mode, this.getTokenAt(pos).state).mode\n\t    },\n\t\n\t    getHelper: function(pos, type) {\n\t      return this.getHelpers(pos, type)[0]\n\t    },\n\t\n\t    getHelpers: function(pos, type) {\n\t      var this$1 = this;\n\t\n\t      var found = []\n\t      if (!helpers.hasOwnProperty(type)) { return found }\n\t      var help = helpers[type], mode = this.getModeAt(pos)\n\t      if (typeof mode[type] == \"string\") {\n\t        if (help[mode[type]]) { found.push(help[mode[type]]) }\n\t      } else if (mode[type]) {\n\t        for (var i = 0; i < mode[type].length; i++) {\n\t          var val = help[mode[type][i]]\n\t          if (val) { found.push(val) }\n\t        }\n\t      } else if (mode.helperType && help[mode.helperType]) {\n\t        found.push(help[mode.helperType])\n\t      } else if (help[mode.name]) {\n\t        found.push(help[mode.name])\n\t      }\n\t      for (var i$1 = 0; i$1 < help._global.length; i$1++) {\n\t        var cur = help._global[i$1]\n\t        if (cur.pred(mode, this$1) && indexOf(found, cur.val) == -1)\n\t          { found.push(cur.val) }\n\t      }\n\t      return found\n\t    },\n\t\n\t    getStateAfter: function(line, precise) {\n\t      var doc = this.doc\n\t      line = clipLine(doc, line == null ? doc.first + doc.size - 1: line)\n\t      return getStateBefore(this, line + 1, precise)\n\t    },\n\t\n\t    cursorCoords: function(start, mode) {\n\t      var pos, range = this.doc.sel.primary()\n\t      if (start == null) { pos = range.head }\n\t      else if (typeof start == \"object\") { pos = clipPos(this.doc, start) }\n\t      else { pos = start ? range.from() : range.to() }\n\t      return cursorCoords(this, pos, mode || \"page\")\n\t    },\n\t\n\t    charCoords: function(pos, mode) {\n\t      return charCoords(this, clipPos(this.doc, pos), mode || \"page\")\n\t    },\n\t\n\t    coordsChar: function(coords, mode) {\n\t      coords = fromCoordSystem(this, coords, mode || \"page\")\n\t      return coordsChar(this, coords.left, coords.top)\n\t    },\n\t\n\t    lineAtHeight: function(height, mode) {\n\t      height = fromCoordSystem(this, {top: height, left: 0}, mode || \"page\").top\n\t      return lineAtHeight(this.doc, height + this.display.viewOffset)\n\t    },\n\t    heightAtLine: function(line, mode, includeWidgets) {\n\t      var end = false, lineObj\n\t      if (typeof line == \"number\") {\n\t        var last = this.doc.first + this.doc.size - 1\n\t        if (line < this.doc.first) { line = this.doc.first }\n\t        else if (line > last) { line = last; end = true }\n\t        lineObj = getLine(this.doc, line)\n\t      } else {\n\t        lineObj = line\n\t      }\n\t      return intoCoordSystem(this, lineObj, {top: 0, left: 0}, mode || \"page\", includeWidgets || end).top +\n\t        (end ? this.doc.height - heightAtLine(lineObj) : 0)\n\t    },\n\t\n\t    defaultTextHeight: function() { return textHeight(this.display) },\n\t    defaultCharWidth: function() { return charWidth(this.display) },\n\t\n\t    getViewport: function() { return {from: this.display.viewFrom, to: this.display.viewTo}},\n\t\n\t    addWidget: function(pos, node, scroll, vert, horiz) {\n\t      var display = this.display\n\t      pos = cursorCoords(this, clipPos(this.doc, pos))\n\t      var top = pos.bottom, left = pos.left\n\t      node.style.position = \"absolute\"\n\t      node.setAttribute(\"cm-ignore-events\", \"true\")\n\t      this.display.input.setUneditable(node)\n\t      display.sizer.appendChild(node)\n\t      if (vert == \"over\") {\n\t        top = pos.top\n\t      } else if (vert == \"above\" || vert == \"near\") {\n\t        var vspace = Math.max(display.wrapper.clientHeight, this.doc.height),\n\t        hspace = Math.max(display.sizer.clientWidth, display.lineSpace.clientWidth)\n\t        // Default to positioning above (if specified and possible); otherwise default to positioning below\n\t        if ((vert == 'above' || pos.bottom + node.offsetHeight > vspace) && pos.top > node.offsetHeight)\n\t          { top = pos.top - node.offsetHeight }\n\t        else if (pos.bottom + node.offsetHeight <= vspace)\n\t          { top = pos.bottom }\n\t        if (left + node.offsetWidth > hspace)\n\t          { left = hspace - node.offsetWidth }\n\t      }\n\t      node.style.top = top + \"px\"\n\t      node.style.left = node.style.right = \"\"\n\t      if (horiz == \"right\") {\n\t        left = display.sizer.clientWidth - node.offsetWidth\n\t        node.style.right = \"0px\"\n\t      } else {\n\t        if (horiz == \"left\") { left = 0 }\n\t        else if (horiz == \"middle\") { left = (display.sizer.clientWidth - node.offsetWidth) / 2 }\n\t        node.style.left = left + \"px\"\n\t      }\n\t      if (scroll)\n\t        { scrollIntoView(this, left, top, left + node.offsetWidth, top + node.offsetHeight) }\n\t    },\n\t\n\t    triggerOnKeyDown: methodOp(onKeyDown),\n\t    triggerOnKeyPress: methodOp(onKeyPress),\n\t    triggerOnKeyUp: onKeyUp,\n\t\n\t    execCommand: function(cmd) {\n\t      if (commands.hasOwnProperty(cmd))\n\t        { return commands[cmd].call(null, this) }\n\t    },\n\t\n\t    triggerElectric: methodOp(function(text) { triggerElectric(this, text) }),\n\t\n\t    findPosH: function(from, amount, unit, visually) {\n\t      var this$1 = this;\n\t\n\t      var dir = 1\n\t      if (amount < 0) { dir = -1; amount = -amount }\n\t      var cur = clipPos(this.doc, from)\n\t      for (var i = 0; i < amount; ++i) {\n\t        cur = findPosH(this$1.doc, cur, dir, unit, visually)\n\t        if (cur.hitSide) { break }\n\t      }\n\t      return cur\n\t    },\n\t\n\t    moveH: methodOp(function(dir, unit) {\n\t      var this$1 = this;\n\t\n\t      this.extendSelectionsBy(function (range) {\n\t        if (this$1.display.shift || this$1.doc.extend || range.empty())\n\t          { return findPosH(this$1.doc, range.head, dir, unit, this$1.options.rtlMoveVisually) }\n\t        else\n\t          { return dir < 0 ? range.from() : range.to() }\n\t      }, sel_move)\n\t    }),\n\t\n\t    deleteH: methodOp(function(dir, unit) {\n\t      var sel = this.doc.sel, doc = this.doc\n\t      if (sel.somethingSelected())\n\t        { doc.replaceSelection(\"\", null, \"+delete\") }\n\t      else\n\t        { deleteNearSelection(this, function (range) {\n\t          var other = findPosH(doc, range.head, dir, unit, false)\n\t          return dir < 0 ? {from: other, to: range.head} : {from: range.head, to: other}\n\t        }) }\n\t    }),\n\t\n\t    findPosV: function(from, amount, unit, goalColumn) {\n\t      var this$1 = this;\n\t\n\t      var dir = 1, x = goalColumn\n\t      if (amount < 0) { dir = -1; amount = -amount }\n\t      var cur = clipPos(this.doc, from)\n\t      for (var i = 0; i < amount; ++i) {\n\t        var coords = cursorCoords(this$1, cur, \"div\")\n\t        if (x == null) { x = coords.left }\n\t        else { coords.left = x }\n\t        cur = findPosV(this$1, coords, dir, unit)\n\t        if (cur.hitSide) { break }\n\t      }\n\t      return cur\n\t    },\n\t\n\t    moveV: methodOp(function(dir, unit) {\n\t      var this$1 = this;\n\t\n\t      var doc = this.doc, goals = []\n\t      var collapse = !this.display.shift && !doc.extend && doc.sel.somethingSelected()\n\t      doc.extendSelectionsBy(function (range) {\n\t        if (collapse)\n\t          { return dir < 0 ? range.from() : range.to() }\n\t        var headPos = cursorCoords(this$1, range.head, \"div\")\n\t        if (range.goalColumn != null) { headPos.left = range.goalColumn }\n\t        goals.push(headPos.left)\n\t        var pos = findPosV(this$1, headPos, dir, unit)\n\t        if (unit == \"page\" && range == doc.sel.primary())\n\t          { addToScrollPos(this$1, null, charCoords(this$1, pos, \"div\").top - headPos.top) }\n\t        return pos\n\t      }, sel_move)\n\t      if (goals.length) { for (var i = 0; i < doc.sel.ranges.length; i++)\n\t        { doc.sel.ranges[i].goalColumn = goals[i] } }\n\t    }),\n\t\n\t    // Find the word at the given position (as returned by coordsChar).\n\t    findWordAt: function(pos) {\n\t      var doc = this.doc, line = getLine(doc, pos.line).text\n\t      var start = pos.ch, end = pos.ch\n\t      if (line) {\n\t        var helper = this.getHelper(pos, \"wordChars\")\n\t        if ((pos.sticky == \"before\" || end == line.length) && start) { --start; } else { ++end }\n\t        var startChar = line.charAt(start)\n\t        var check = isWordChar(startChar, helper)\n\t          ? function (ch) { return isWordChar(ch, helper); }\n\t          : /\\s/.test(startChar) ? function (ch) { return /\\s/.test(ch); }\n\t          : function (ch) { return (!/\\s/.test(ch) && !isWordChar(ch)); }\n\t        while (start > 0 && check(line.charAt(start - 1))) { --start }\n\t        while (end < line.length && check(line.charAt(end))) { ++end }\n\t      }\n\t      return new Range(Pos(pos.line, start), Pos(pos.line, end))\n\t    },\n\t\n\t    toggleOverwrite: function(value) {\n\t      if (value != null && value == this.state.overwrite) { return }\n\t      if (this.state.overwrite = !this.state.overwrite)\n\t        { addClass(this.display.cursorDiv, \"CodeMirror-overwrite\") }\n\t      else\n\t        { rmClass(this.display.cursorDiv, \"CodeMirror-overwrite\") }\n\t\n\t      signal(this, \"overwriteToggle\", this, this.state.overwrite)\n\t    },\n\t    hasFocus: function() { return this.display.input.getField() == activeElt() },\n\t    isReadOnly: function() { return !!(this.options.readOnly || this.doc.cantEdit) },\n\t\n\t    scrollTo: methodOp(function(x, y) {\n\t      if (x != null || y != null) { resolveScrollToPos(this) }\n\t      if (x != null) { this.curOp.scrollLeft = x }\n\t      if (y != null) { this.curOp.scrollTop = y }\n\t    }),\n\t    getScrollInfo: function() {\n\t      var scroller = this.display.scroller\n\t      return {left: scroller.scrollLeft, top: scroller.scrollTop,\n\t              height: scroller.scrollHeight - scrollGap(this) - this.display.barHeight,\n\t              width: scroller.scrollWidth - scrollGap(this) - this.display.barWidth,\n\t              clientHeight: displayHeight(this), clientWidth: displayWidth(this)}\n\t    },\n\t\n\t    scrollIntoView: methodOp(function(range, margin) {\n\t      if (range == null) {\n\t        range = {from: this.doc.sel.primary().head, to: null}\n\t        if (margin == null) { margin = this.options.cursorScrollMargin }\n\t      } else if (typeof range == \"number\") {\n\t        range = {from: Pos(range, 0), to: null}\n\t      } else if (range.from == null) {\n\t        range = {from: range, to: null}\n\t      }\n\t      if (!range.to) { range.to = range.from }\n\t      range.margin = margin || 0\n\t\n\t      if (range.from.line != null) {\n\t        resolveScrollToPos(this)\n\t        this.curOp.scrollToPos = range\n\t      } else {\n\t        var sPos = calculateScrollPos(this, Math.min(range.from.left, range.to.left),\n\t                                      Math.min(range.from.top, range.to.top) - range.margin,\n\t                                      Math.max(range.from.right, range.to.right),\n\t                                      Math.max(range.from.bottom, range.to.bottom) + range.margin)\n\t        this.scrollTo(sPos.scrollLeft, sPos.scrollTop)\n\t      }\n\t    }),\n\t\n\t    setSize: methodOp(function(width, height) {\n\t      var this$1 = this;\n\t\n\t      var interpret = function (val) { return typeof val == \"number\" || /^\\d+$/.test(String(val)) ? val + \"px\" : val; }\n\t      if (width != null) { this.display.wrapper.style.width = interpret(width) }\n\t      if (height != null) { this.display.wrapper.style.height = interpret(height) }\n\t      if (this.options.lineWrapping) { clearLineMeasurementCache(this) }\n\t      var lineNo = this.display.viewFrom\n\t      this.doc.iter(lineNo, this.display.viewTo, function (line) {\n\t        if (line.widgets) { for (var i = 0; i < line.widgets.length; i++)\n\t          { if (line.widgets[i].noHScroll) { regLineChange(this$1, lineNo, \"widget\"); break } } }\n\t        ++lineNo\n\t      })\n\t      this.curOp.forceUpdate = true\n\t      signal(this, \"refresh\", this)\n\t    }),\n\t\n\t    operation: function(f){return runInOp(this, f)},\n\t\n\t    refresh: methodOp(function() {\n\t      var oldHeight = this.display.cachedTextHeight\n\t      regChange(this)\n\t      this.curOp.forceUpdate = true\n\t      clearCaches(this)\n\t      this.scrollTo(this.doc.scrollLeft, this.doc.scrollTop)\n\t      updateGutterSpace(this)\n\t      if (oldHeight == null || Math.abs(oldHeight - textHeight(this.display)) > .5)\n\t        { estimateLineHeights(this) }\n\t      signal(this, \"refresh\", this)\n\t    }),\n\t\n\t    swapDoc: methodOp(function(doc) {\n\t      var old = this.doc\n\t      old.cm = null\n\t      attachDoc(this, doc)\n\t      clearCaches(this)\n\t      this.display.input.reset()\n\t      this.scrollTo(doc.scrollLeft, doc.scrollTop)\n\t      this.curOp.forceScroll = true\n\t      signalLater(this, \"swapDoc\", this, old)\n\t      return old\n\t    }),\n\t\n\t    getInputField: function(){return this.display.input.getField()},\n\t    getWrapperElement: function(){return this.display.wrapper},\n\t    getScrollerElement: function(){return this.display.scroller},\n\t    getGutterElement: function(){return this.display.gutters}\n\t  }\n\t  eventMixin(CodeMirror)\n\t\n\t  CodeMirror.registerHelper = function(type, name, value) {\n\t    if (!helpers.hasOwnProperty(type)) { helpers[type] = CodeMirror[type] = {_global: []} }\n\t    helpers[type][name] = value\n\t  }\n\t  CodeMirror.registerGlobalHelper = function(type, name, predicate, value) {\n\t    CodeMirror.registerHelper(type, name, value)\n\t    helpers[type]._global.push({pred: predicate, val: value})\n\t  }\n\t}\n\t\n\t// Used for horizontal relative motion. Dir is -1 or 1 (left or\n\t// right), unit can be \"char\", \"column\" (like char, but doesn't\n\t// cross line boundaries), \"word\" (across next word), or \"group\" (to\n\t// the start of next group of word or non-word-non-whitespace\n\t// chars). The visually param controls whether, in right-to-left\n\t// text, direction 1 means to move towards the next index in the\n\t// string, or towards the character to the right of the current\n\t// position. The resulting position will have a hitSide=true\n\t// property if it reached the end of the document.\n\tfunction findPosH(doc, pos, dir, unit, visually) {\n\t  var oldPos = pos\n\t  var origDir = dir\n\t  var lineObj = getLine(doc, pos.line)\n\t  function findNextLine() {\n\t    var l = pos.line + dir\n\t    if (l < doc.first || l >= doc.first + doc.size) { return false }\n\t    pos = new Pos(l, pos.ch, pos.sticky)\n\t    return lineObj = getLine(doc, l)\n\t  }\n\t  function moveOnce(boundToLine) {\n\t    var next\n\t    if (visually) {\n\t      next = moveVisually(doc.cm, lineObj, pos, dir)\n\t    } else {\n\t      next = moveLogically(lineObj, pos, dir)\n\t    }\n\t    if (next == null) {\n\t      if (!boundToLine && findNextLine())\n\t        { pos = endOfLine(visually, doc.cm, lineObj, pos.line, dir) }\n\t      else\n\t        { return false }\n\t    } else {\n\t      pos = next\n\t    }\n\t    return true\n\t  }\n\t\n\t  if (unit == \"char\") {\n\t    moveOnce()\n\t  } else if (unit == \"column\") {\n\t    moveOnce(true)\n\t  } else if (unit == \"word\" || unit == \"group\") {\n\t    var sawType = null, group = unit == \"group\"\n\t    var helper = doc.cm && doc.cm.getHelper(pos, \"wordChars\")\n\t    for (var first = true;; first = false) {\n\t      if (dir < 0 && !moveOnce(!first)) { break }\n\t      var cur = lineObj.text.charAt(pos.ch) || \"\\n\"\n\t      var type = isWordChar(cur, helper) ? \"w\"\n\t        : group && cur == \"\\n\" ? \"n\"\n\t        : !group || /\\s/.test(cur) ? null\n\t        : \"p\"\n\t      if (group && !first && !type) { type = \"s\" }\n\t      if (sawType && sawType != type) {\n\t        if (dir < 0) {dir = 1; moveOnce(); pos.sticky = \"after\"}\n\t        break\n\t      }\n\t\n\t      if (type) { sawType = type }\n\t      if (dir > 0 && !moveOnce(!first)) { break }\n\t    }\n\t  }\n\t  var result = skipAtomic(doc, pos, oldPos, origDir, true)\n\t  if (equalCursorPos(oldPos, result)) { result.hitSide = true }\n\t  return result\n\t}\n\t\n\t// For relative vertical movement. Dir may be -1 or 1. Unit can be\n\t// \"page\" or \"line\". The resulting position will have a hitSide=true\n\t// property if it reached the end of the document.\n\tfunction findPosV(cm, pos, dir, unit) {\n\t  var doc = cm.doc, x = pos.left, y\n\t  if (unit == \"page\") {\n\t    var pageSize = Math.min(cm.display.wrapper.clientHeight, window.innerHeight || document.documentElement.clientHeight)\n\t    var moveAmount = Math.max(pageSize - .5 * textHeight(cm.display), 3)\n\t    y = (dir > 0 ? pos.bottom : pos.top) + dir * moveAmount\n\t\n\t  } else if (unit == \"line\") {\n\t    y = dir > 0 ? pos.bottom + 3 : pos.top - 3\n\t  }\n\t  var target\n\t  for (;;) {\n\t    target = coordsChar(cm, x, y)\n\t    if (!target.outside) { break }\n\t    if (dir < 0 ? y <= 0 : y >= doc.height) { target.hitSide = true; break }\n\t    y += dir * 5\n\t  }\n\t  return target\n\t}\n\t\n\t// CONTENTEDITABLE INPUT STYLE\n\t\n\tvar ContentEditableInput = function(cm) {\n\t  this.cm = cm\n\t  this.lastAnchorNode = this.lastAnchorOffset = this.lastFocusNode = this.lastFocusOffset = null\n\t  this.polling = new Delayed()\n\t  this.composing = null\n\t  this.gracePeriod = false\n\t  this.readDOMTimeout = null\n\t};\n\t\n\tContentEditableInput.prototype.init = function (display) {\n\t    var this$1 = this;\n\t\n\t  var input = this, cm = input.cm\n\t  var div = input.div = display.lineDiv\n\t  disableBrowserMagic(div, cm.options.spellcheck)\n\t\n\t  on(div, \"paste\", function (e) {\n\t    if (signalDOMEvent(cm, e) || handlePaste(e, cm)) { return }\n\t    // IE doesn't fire input events, so we schedule a read for the pasted content in this way\n\t    if (ie_version <= 11) { setTimeout(operation(cm, function () {\n\t      if (!input.pollContent()) { regChange(cm) }\n\t    }), 20) }\n\t  })\n\t\n\t  on(div, \"compositionstart\", function (e) {\n\t    this$1.composing = {data: e.data, done: false}\n\t  })\n\t  on(div, \"compositionupdate\", function (e) {\n\t    if (!this$1.composing) { this$1.composing = {data: e.data, done: false} }\n\t  })\n\t  on(div, \"compositionend\", function (e) {\n\t    if (this$1.composing) {\n\t      if (e.data != this$1.composing.data) { this$1.readFromDOMSoon() }\n\t      this$1.composing.done = true\n\t    }\n\t  })\n\t\n\t  on(div, \"touchstart\", function () { return input.forceCompositionEnd(); })\n\t\n\t  on(div, \"input\", function () {\n\t    if (!this$1.composing) { this$1.readFromDOMSoon() }\n\t  })\n\t\n\t  function onCopyCut(e) {\n\t    if (signalDOMEvent(cm, e)) { return }\n\t    if (cm.somethingSelected()) {\n\t      setLastCopied({lineWise: false, text: cm.getSelections()})\n\t      if (e.type == \"cut\") { cm.replaceSelection(\"\", null, \"cut\") }\n\t    } else if (!cm.options.lineWiseCopyCut) {\n\t      return\n\t    } else {\n\t      var ranges = copyableRanges(cm)\n\t      setLastCopied({lineWise: true, text: ranges.text})\n\t      if (e.type == \"cut\") {\n\t        cm.operation(function () {\n\t          cm.setSelections(ranges.ranges, 0, sel_dontScroll)\n\t          cm.replaceSelection(\"\", null, \"cut\")\n\t        })\n\t      }\n\t    }\n\t    if (e.clipboardData) {\n\t      e.clipboardData.clearData()\n\t      var content = lastCopied.text.join(\"\\n\")\n\t      // iOS exposes the clipboard API, but seems to discard content inserted into it\n\t      e.clipboardData.setData(\"Text\", content)\n\t      if (e.clipboardData.getData(\"Text\") == content) {\n\t        e.preventDefault()\n\t        return\n\t      }\n\t    }\n\t    // Old-fashioned briefly-focus-a-textarea hack\n\t    var kludge = hiddenTextarea(), te = kludge.firstChild\n\t    cm.display.lineSpace.insertBefore(kludge, cm.display.lineSpace.firstChild)\n\t    te.value = lastCopied.text.join(\"\\n\")\n\t    var hadFocus = document.activeElement\n\t    selectInput(te)\n\t    setTimeout(function () {\n\t      cm.display.lineSpace.removeChild(kludge)\n\t      hadFocus.focus()\n\t      if (hadFocus == div) { input.showPrimarySelection() }\n\t    }, 50)\n\t  }\n\t  on(div, \"copy\", onCopyCut)\n\t  on(div, \"cut\", onCopyCut)\n\t};\n\t\n\tContentEditableInput.prototype.prepareSelection = function () {\n\t  var result = prepareSelection(this.cm, false)\n\t  result.focus = this.cm.state.focused\n\t  return result\n\t};\n\t\n\tContentEditableInput.prototype.showSelection = function (info, takeFocus) {\n\t  if (!info || !this.cm.display.view.length) { return }\n\t  if (info.focus || takeFocus) { this.showPrimarySelection() }\n\t  this.showMultipleSelections(info)\n\t};\n\t\n\tContentEditableInput.prototype.showPrimarySelection = function () {\n\t  var sel = window.getSelection(), prim = this.cm.doc.sel.primary()\n\t  var curAnchor = domToPos(this.cm, sel.anchorNode, sel.anchorOffset)\n\t  var curFocus = domToPos(this.cm, sel.focusNode, sel.focusOffset)\n\t  if (curAnchor && !curAnchor.bad && curFocus && !curFocus.bad &&\n\t      cmp(minPos(curAnchor, curFocus), prim.from()) == 0 &&\n\t      cmp(maxPos(curAnchor, curFocus), prim.to()) == 0)\n\t    { return }\n\t\n\t  var start = posToDOM(this.cm, prim.from())\n\t  var end = posToDOM(this.cm, prim.to())\n\t  if (!start && !end) { return }\n\t\n\t  var view = this.cm.display.view\n\t  var old = sel.rangeCount && sel.getRangeAt(0)\n\t  if (!start) {\n\t    start = {node: view[0].measure.map[2], offset: 0}\n\t  } else if (!end) { // FIXME dangerously hacky\n\t    var measure = view[view.length - 1].measure\n\t    var map = measure.maps ? measure.maps[measure.maps.length - 1] : measure.map\n\t    end = {node: map[map.length - 1], offset: map[map.length - 2] - map[map.length - 3]}\n\t  }\n\t\n\t  var rng\n\t  try { rng = range(start.node, start.offset, end.offset, end.node) }\n\t  catch(e) {} // Our model of the DOM might be outdated, in which case the range we try to set can be impossible\n\t  if (rng) {\n\t    if (!gecko && this.cm.state.focused) {\n\t      sel.collapse(start.node, start.offset)\n\t      if (!rng.collapsed) {\n\t        sel.removeAllRanges()\n\t        sel.addRange(rng)\n\t      }\n\t    } else {\n\t      sel.removeAllRanges()\n\t      sel.addRange(rng)\n\t    }\n\t    if (old && sel.anchorNode == null) { sel.addRange(old) }\n\t    else if (gecko) { this.startGracePeriod() }\n\t  }\n\t  this.rememberSelection()\n\t};\n\t\n\tContentEditableInput.prototype.startGracePeriod = function () {\n\t    var this$1 = this;\n\t\n\t  clearTimeout(this.gracePeriod)\n\t  this.gracePeriod = setTimeout(function () {\n\t    this$1.gracePeriod = false\n\t    if (this$1.selectionChanged())\n\t      { this$1.cm.operation(function () { return this$1.cm.curOp.selectionChanged = true; }) }\n\t  }, 20)\n\t};\n\t\n\tContentEditableInput.prototype.showMultipleSelections = function (info) {\n\t  removeChildrenAndAdd(this.cm.display.cursorDiv, info.cursors)\n\t  removeChildrenAndAdd(this.cm.display.selectionDiv, info.selection)\n\t};\n\t\n\tContentEditableInput.prototype.rememberSelection = function () {\n\t  var sel = window.getSelection()\n\t  this.lastAnchorNode = sel.anchorNode; this.lastAnchorOffset = sel.anchorOffset\n\t  this.lastFocusNode = sel.focusNode; this.lastFocusOffset = sel.focusOffset\n\t};\n\t\n\tContentEditableInput.prototype.selectionInEditor = function () {\n\t  var sel = window.getSelection()\n\t  if (!sel.rangeCount) { return false }\n\t  var node = sel.getRangeAt(0).commonAncestorContainer\n\t  return contains(this.div, node)\n\t};\n\t\n\tContentEditableInput.prototype.focus = function () {\n\t  if (this.cm.options.readOnly != \"nocursor\") {\n\t    if (!this.selectionInEditor())\n\t      { this.showSelection(this.prepareSelection(), true) }\n\t    this.div.focus()\n\t  }\n\t};\n\tContentEditableInput.prototype.blur = function () { this.div.blur() };\n\tContentEditableInput.prototype.getField = function () { return this.div };\n\t\n\tContentEditableInput.prototype.supportsTouch = function () { return true };\n\t\n\tContentEditableInput.prototype.receivedFocus = function () {\n\t  var input = this\n\t  if (this.selectionInEditor())\n\t    { this.pollSelection() }\n\t  else\n\t    { runInOp(this.cm, function () { return input.cm.curOp.selectionChanged = true; }) }\n\t\n\t  function poll() {\n\t    if (input.cm.state.focused) {\n\t      input.pollSelection()\n\t      input.polling.set(input.cm.options.pollInterval, poll)\n\t    }\n\t  }\n\t  this.polling.set(this.cm.options.pollInterval, poll)\n\t};\n\t\n\tContentEditableInput.prototype.selectionChanged = function () {\n\t  var sel = window.getSelection()\n\t  return sel.anchorNode != this.lastAnchorNode || sel.anchorOffset != this.lastAnchorOffset ||\n\t    sel.focusNode != this.lastFocusNode || sel.focusOffset != this.lastFocusOffset\n\t};\n\t\n\tContentEditableInput.prototype.pollSelection = function () {\n\t  if (!this.composing && this.readDOMTimeout == null && !this.gracePeriod && this.selectionChanged()) {\n\t    var sel = window.getSelection(), cm = this.cm\n\t    this.rememberSelection()\n\t    var anchor = domToPos(cm, sel.anchorNode, sel.anchorOffset)\n\t    var head = domToPos(cm, sel.focusNode, sel.focusOffset)\n\t    if (anchor && head) { runInOp(cm, function () {\n\t      setSelection(cm.doc, simpleSelection(anchor, head), sel_dontScroll)\n\t      if (anchor.bad || head.bad) { cm.curOp.selectionChanged = true }\n\t    }) }\n\t  }\n\t};\n\t\n\tContentEditableInput.prototype.pollContent = function () {\n\t  if (this.readDOMTimeout != null) {\n\t    clearTimeout(this.readDOMTimeout)\n\t    this.readDOMTimeout = null\n\t  }\n\t\n\t  var cm = this.cm, display = cm.display, sel = cm.doc.sel.primary()\n\t  var from = sel.from(), to = sel.to()\n\t  if (from.ch == 0 && from.line > cm.firstLine())\n\t    { from = Pos(from.line - 1, getLine(cm.doc, from.line - 1).length) }\n\t  if (to.ch == getLine(cm.doc, to.line).text.length && to.line < cm.lastLine())\n\t    { to = Pos(to.line + 1, 0) }\n\t  if (from.line < display.viewFrom || to.line > display.viewTo - 1) { return false }\n\t\n\t  var fromIndex, fromLine, fromNode\n\t  if (from.line == display.viewFrom || (fromIndex = findViewIndex(cm, from.line)) == 0) {\n\t    fromLine = lineNo(display.view[0].line)\n\t    fromNode = display.view[0].node\n\t  } else {\n\t    fromLine = lineNo(display.view[fromIndex].line)\n\t    fromNode = display.view[fromIndex - 1].node.nextSibling\n\t  }\n\t  var toIndex = findViewIndex(cm, to.line)\n\t  var toLine, toNode\n\t  if (toIndex == display.view.length - 1) {\n\t    toLine = display.viewTo - 1\n\t    toNode = display.lineDiv.lastChild\n\t  } else {\n\t    toLine = lineNo(display.view[toIndex + 1].line) - 1\n\t    toNode = display.view[toIndex + 1].node.previousSibling\n\t  }\n\t\n\t  if (!fromNode) { return false }\n\t  var newText = cm.doc.splitLines(domTextBetween(cm, fromNode, toNode, fromLine, toLine))\n\t  var oldText = getBetween(cm.doc, Pos(fromLine, 0), Pos(toLine, getLine(cm.doc, toLine).text.length))\n\t  while (newText.length > 1 && oldText.length > 1) {\n\t    if (lst(newText) == lst(oldText)) { newText.pop(); oldText.pop(); toLine-- }\n\t    else if (newText[0] == oldText[0]) { newText.shift(); oldText.shift(); fromLine++ }\n\t    else { break }\n\t  }\n\t\n\t  var cutFront = 0, cutEnd = 0\n\t  var newTop = newText[0], oldTop = oldText[0], maxCutFront = Math.min(newTop.length, oldTop.length)\n\t  while (cutFront < maxCutFront && newTop.charCodeAt(cutFront) == oldTop.charCodeAt(cutFront))\n\t    { ++cutFront }\n\t  var newBot = lst(newText), oldBot = lst(oldText)\n\t  var maxCutEnd = Math.min(newBot.length - (newText.length == 1 ? cutFront : 0),\n\t                           oldBot.length - (oldText.length == 1 ? cutFront : 0))\n\t  while (cutEnd < maxCutEnd &&\n\t         newBot.charCodeAt(newBot.length - cutEnd - 1) == oldBot.charCodeAt(oldBot.length - cutEnd - 1))\n\t    { ++cutEnd }\n\t\n\t  newText[newText.length - 1] = newBot.slice(0, newBot.length - cutEnd).replace(/^\\u200b+/, \"\")\n\t  newText[0] = newText[0].slice(cutFront).replace(/\\u200b+$/, \"\")\n\t\n\t  var chFrom = Pos(fromLine, cutFront)\n\t  var chTo = Pos(toLine, oldText.length ? lst(oldText).length - cutEnd : 0)\n\t  if (newText.length > 1 || newText[0] || cmp(chFrom, chTo)) {\n\t    replaceRange(cm.doc, newText, chFrom, chTo, \"+input\")\n\t    return true\n\t  }\n\t};\n\t\n\tContentEditableInput.prototype.ensurePolled = function () {\n\t  this.forceCompositionEnd()\n\t};\n\tContentEditableInput.prototype.reset = function () {\n\t  this.forceCompositionEnd()\n\t};\n\tContentEditableInput.prototype.forceCompositionEnd = function () {\n\t  if (!this.composing) { return }\n\t  clearTimeout(this.readDOMTimeout)\n\t  this.composing = null\n\t  if (!this.pollContent()) { regChange(this.cm) }\n\t  this.div.blur()\n\t  this.div.focus()\n\t};\n\tContentEditableInput.prototype.readFromDOMSoon = function () {\n\t    var this$1 = this;\n\t\n\t  if (this.readDOMTimeout != null) { return }\n\t  this.readDOMTimeout = setTimeout(function () {\n\t    this$1.readDOMTimeout = null\n\t    if (this$1.composing) {\n\t      if (this$1.composing.done) { this$1.composing = null }\n\t      else { return }\n\t    }\n\t    if (this$1.cm.isReadOnly() || !this$1.pollContent())\n\t      { runInOp(this$1.cm, function () { return regChange(this$1.cm); }) }\n\t  }, 80)\n\t};\n\t\n\tContentEditableInput.prototype.setUneditable = function (node) {\n\t  node.contentEditable = \"false\"\n\t};\n\t\n\tContentEditableInput.prototype.onKeyPress = function (e) {\n\t  if (e.charCode == 0) { return }\n\t  e.preventDefault()\n\t  if (!this.cm.isReadOnly())\n\t    { operation(this.cm, applyTextInput)(this.cm, String.fromCharCode(e.charCode == null ? e.keyCode : e.charCode), 0) }\n\t};\n\t\n\tContentEditableInput.prototype.readOnlyChanged = function (val) {\n\t  this.div.contentEditable = String(val != \"nocursor\")\n\t};\n\t\n\tContentEditableInput.prototype.onContextMenu = function () {};\n\tContentEditableInput.prototype.resetPosition = function () {};\n\t\n\tContentEditableInput.prototype.needsContentAttribute = true\n\t\n\tfunction posToDOM(cm, pos) {\n\t  var view = findViewForLine(cm, pos.line)\n\t  if (!view || view.hidden) { return null }\n\t  var line = getLine(cm.doc, pos.line)\n\t  var info = mapFromLineView(view, line, pos.line)\n\t\n\t  var order = getOrder(line), side = \"left\"\n\t  if (order) {\n\t    var partPos = getBidiPartAt(order, pos.ch)\n\t    side = partPos % 2 ? \"right\" : \"left\"\n\t  }\n\t  var result = nodeAndOffsetInLineMap(info.map, pos.ch, side)\n\t  result.offset = result.collapse == \"right\" ? result.end : result.start\n\t  return result\n\t}\n\t\n\tfunction badPos(pos, bad) { if (bad) { pos.bad = true; } return pos }\n\t\n\tfunction domTextBetween(cm, from, to, fromLine, toLine) {\n\t  var text = \"\", closing = false, lineSep = cm.doc.lineSeparator()\n\t  function recognizeMarker(id) { return function (marker) { return marker.id == id; } }\n\t  function walk(node) {\n\t    if (node.nodeType == 1) {\n\t      var cmText = node.getAttribute(\"cm-text\")\n\t      if (cmText != null) {\n\t        if (cmText == \"\") { text += node.textContent.replace(/\\u200b/g, \"\") }\n\t        else { text += cmText }\n\t        return\n\t      }\n\t      var markerID = node.getAttribute(\"cm-marker\"), range\n\t      if (markerID) {\n\t        var found = cm.findMarks(Pos(fromLine, 0), Pos(toLine + 1, 0), recognizeMarker(+markerID))\n\t        if (found.length && (range = found[0].find()))\n\t          { text += getBetween(cm.doc, range.from, range.to).join(lineSep) }\n\t        return\n\t      }\n\t      if (node.getAttribute(\"contenteditable\") == \"false\") { return }\n\t      for (var i = 0; i < node.childNodes.length; i++)\n\t        { walk(node.childNodes[i]) }\n\t      if (/^(pre|div|p)$/i.test(node.nodeName))\n\t        { closing = true }\n\t    } else if (node.nodeType == 3) {\n\t      var val = node.nodeValue\n\t      if (!val) { return }\n\t      if (closing) {\n\t        text += lineSep\n\t        closing = false\n\t      }\n\t      text += val\n\t    }\n\t  }\n\t  for (;;) {\n\t    walk(from)\n\t    if (from == to) { break }\n\t    from = from.nextSibling\n\t  }\n\t  return text\n\t}\n\t\n\tfunction domToPos(cm, node, offset) {\n\t  var lineNode\n\t  if (node == cm.display.lineDiv) {\n\t    lineNode = cm.display.lineDiv.childNodes[offset]\n\t    if (!lineNode) { return badPos(cm.clipPos(Pos(cm.display.viewTo - 1)), true) }\n\t    node = null; offset = 0\n\t  } else {\n\t    for (lineNode = node;; lineNode = lineNode.parentNode) {\n\t      if (!lineNode || lineNode == cm.display.lineDiv) { return null }\n\t      if (lineNode.parentNode && lineNode.parentNode == cm.display.lineDiv) { break }\n\t    }\n\t  }\n\t  for (var i = 0; i < cm.display.view.length; i++) {\n\t    var lineView = cm.display.view[i]\n\t    if (lineView.node == lineNode)\n\t      { return locateNodeInLineView(lineView, node, offset) }\n\t  }\n\t}\n\t\n\tfunction locateNodeInLineView(lineView, node, offset) {\n\t  var wrapper = lineView.text.firstChild, bad = false\n\t  if (!node || !contains(wrapper, node)) { return badPos(Pos(lineNo(lineView.line), 0), true) }\n\t  if (node == wrapper) {\n\t    bad = true\n\t    node = wrapper.childNodes[offset]\n\t    offset = 0\n\t    if (!node) {\n\t      var line = lineView.rest ? lst(lineView.rest) : lineView.line\n\t      return badPos(Pos(lineNo(line), line.text.length), bad)\n\t    }\n\t  }\n\t\n\t  var textNode = node.nodeType == 3 ? node : null, topNode = node\n\t  if (!textNode && node.childNodes.length == 1 && node.firstChild.nodeType == 3) {\n\t    textNode = node.firstChild\n\t    if (offset) { offset = textNode.nodeValue.length }\n\t  }\n\t  while (topNode.parentNode != wrapper) { topNode = topNode.parentNode }\n\t  var measure = lineView.measure, maps = measure.maps\n\t\n\t  function find(textNode, topNode, offset) {\n\t    for (var i = -1; i < (maps ? maps.length : 0); i++) {\n\t      var map = i < 0 ? measure.map : maps[i]\n\t      for (var j = 0; j < map.length; j += 3) {\n\t        var curNode = map[j + 2]\n\t        if (curNode == textNode || curNode == topNode) {\n\t          var line = lineNo(i < 0 ? lineView.line : lineView.rest[i])\n\t          var ch = map[j] + offset\n\t          if (offset < 0 || curNode != textNode) { ch = map[j + (offset ? 1 : 0)] }\n\t          return Pos(line, ch)\n\t        }\n\t      }\n\t    }\n\t  }\n\t  var found = find(textNode, topNode, offset)\n\t  if (found) { return badPos(found, bad) }\n\t\n\t  // FIXME this is all really shaky. might handle the few cases it needs to handle, but likely to cause problems\n\t  for (var after = topNode.nextSibling, dist = textNode ? textNode.nodeValue.length - offset : 0; after; after = after.nextSibling) {\n\t    found = find(after, after.firstChild, 0)\n\t    if (found)\n\t      { return badPos(Pos(found.line, found.ch - dist), bad) }\n\t    else\n\t      { dist += after.textContent.length }\n\t  }\n\t  for (var before = topNode.previousSibling, dist$1 = offset; before; before = before.previousSibling) {\n\t    found = find(before, before.firstChild, -1)\n\t    if (found)\n\t      { return badPos(Pos(found.line, found.ch + dist$1), bad) }\n\t    else\n\t      { dist$1 += before.textContent.length }\n\t  }\n\t}\n\t\n\t// TEXTAREA INPUT STYLE\n\t\n\tvar TextareaInput = function(cm) {\n\t  this.cm = cm\n\t  // See input.poll and input.reset\n\t  this.prevInput = \"\"\n\t\n\t  // Flag that indicates whether we expect input to appear real soon\n\t  // now (after some event like 'keypress' or 'input') and are\n\t  // polling intensively.\n\t  this.pollingFast = false\n\t  // Self-resetting timeout for the poller\n\t  this.polling = new Delayed()\n\t  // Tracks when input.reset has punted to just putting a short\n\t  // string into the textarea instead of the full selection.\n\t  this.inaccurateSelection = false\n\t  // Used to work around IE issue with selection being forgotten when focus moves away from textarea\n\t  this.hasSelection = false\n\t  this.composing = null\n\t};\n\t\n\tTextareaInput.prototype.init = function (display) {\n\t    var this$1 = this;\n\t\n\t  var input = this, cm = this.cm\n\t\n\t  // Wraps and hides input textarea\n\t  var div = this.wrapper = hiddenTextarea()\n\t  // The semihidden textarea that is focused when the editor is\n\t  // focused, and receives input.\n\t  var te = this.textarea = div.firstChild\n\t  display.wrapper.insertBefore(div, display.wrapper.firstChild)\n\t\n\t  // Needed to hide big blue blinking cursor on Mobile Safari (doesn't seem to work in iOS 8 anymore)\n\t  if (ios) { te.style.width = \"0px\" }\n\t\n\t  on(te, \"input\", function () {\n\t    if (ie && ie_version >= 9 && this$1.hasSelection) { this$1.hasSelection = null }\n\t    input.poll()\n\t  })\n\t\n\t  on(te, \"paste\", function (e) {\n\t    if (signalDOMEvent(cm, e) || handlePaste(e, cm)) { return }\n\t\n\t    cm.state.pasteIncoming = true\n\t    input.fastPoll()\n\t  })\n\t\n\t  function prepareCopyCut(e) {\n\t    if (signalDOMEvent(cm, e)) { return }\n\t    if (cm.somethingSelected()) {\n\t      setLastCopied({lineWise: false, text: cm.getSelections()})\n\t      if (input.inaccurateSelection) {\n\t        input.prevInput = \"\"\n\t        input.inaccurateSelection = false\n\t        te.value = lastCopied.text.join(\"\\n\")\n\t        selectInput(te)\n\t      }\n\t    } else if (!cm.options.lineWiseCopyCut) {\n\t      return\n\t    } else {\n\t      var ranges = copyableRanges(cm)\n\t      setLastCopied({lineWise: true, text: ranges.text})\n\t      if (e.type == \"cut\") {\n\t        cm.setSelections(ranges.ranges, null, sel_dontScroll)\n\t      } else {\n\t        input.prevInput = \"\"\n\t        te.value = ranges.text.join(\"\\n\")\n\t        selectInput(te)\n\t      }\n\t    }\n\t    if (e.type == \"cut\") { cm.state.cutIncoming = true }\n\t  }\n\t  on(te, \"cut\", prepareCopyCut)\n\t  on(te, \"copy\", prepareCopyCut)\n\t\n\t  on(display.scroller, \"paste\", function (e) {\n\t    if (eventInWidget(display, e) || signalDOMEvent(cm, e)) { return }\n\t    cm.state.pasteIncoming = true\n\t    input.focus()\n\t  })\n\t\n\t  // Prevent normal selection in the editor (we handle our own)\n\t  on(display.lineSpace, \"selectstart\", function (e) {\n\t    if (!eventInWidget(display, e)) { e_preventDefault(e) }\n\t  })\n\t\n\t  on(te, \"compositionstart\", function () {\n\t    var start = cm.getCursor(\"from\")\n\t    if (input.composing) { input.composing.range.clear() }\n\t    input.composing = {\n\t      start: start,\n\t      range: cm.markText(start, cm.getCursor(\"to\"), {className: \"CodeMirror-composing\"})\n\t    }\n\t  })\n\t  on(te, \"compositionend\", function () {\n\t    if (input.composing) {\n\t      input.poll()\n\t      input.composing.range.clear()\n\t      input.composing = null\n\t    }\n\t  })\n\t};\n\t\n\tTextareaInput.prototype.prepareSelection = function () {\n\t  // Redraw the selection and/or cursor\n\t  var cm = this.cm, display = cm.display, doc = cm.doc\n\t  var result = prepareSelection(cm)\n\t\n\t  // Move the hidden textarea near the cursor to prevent scrolling artifacts\n\t  if (cm.options.moveInputWithCursor) {\n\t    var headPos = cursorCoords(cm, doc.sel.primary().head, \"div\")\n\t    var wrapOff = display.wrapper.getBoundingClientRect(), lineOff = display.lineDiv.getBoundingClientRect()\n\t    result.teTop = Math.max(0, Math.min(display.wrapper.clientHeight - 10,\n\t                                        headPos.top + lineOff.top - wrapOff.top))\n\t    result.teLeft = Math.max(0, Math.min(display.wrapper.clientWidth - 10,\n\t                                         headPos.left + lineOff.left - wrapOff.left))\n\t  }\n\t\n\t  return result\n\t};\n\t\n\tTextareaInput.prototype.showSelection = function (drawn) {\n\t  var cm = this.cm, display = cm.display\n\t  removeChildrenAndAdd(display.cursorDiv, drawn.cursors)\n\t  removeChildrenAndAdd(display.selectionDiv, drawn.selection)\n\t  if (drawn.teTop != null) {\n\t    this.wrapper.style.top = drawn.teTop + \"px\"\n\t    this.wrapper.style.left = drawn.teLeft + \"px\"\n\t  }\n\t};\n\t\n\t// Reset the input to correspond to the selection (or to be empty,\n\t// when not typing and nothing is selected)\n\tTextareaInput.prototype.reset = function (typing) {\n\t  if (this.contextMenuPending) { return }\n\t  var minimal, selected, cm = this.cm, doc = cm.doc\n\t  if (cm.somethingSelected()) {\n\t    this.prevInput = \"\"\n\t    var range = doc.sel.primary()\n\t    minimal = hasCopyEvent &&\n\t      (range.to().line - range.from().line > 100 || (selected = cm.getSelection()).length > 1000)\n\t    var content = minimal ? \"-\" : selected || cm.getSelection()\n\t    this.textarea.value = content\n\t    if (cm.state.focused) { selectInput(this.textarea) }\n\t    if (ie && ie_version >= 9) { this.hasSelection = content }\n\t  } else if (!typing) {\n\t    this.prevInput = this.textarea.value = \"\"\n\t    if (ie && ie_version >= 9) { this.hasSelection = null }\n\t  }\n\t  this.inaccurateSelection = minimal\n\t};\n\t\n\tTextareaInput.prototype.getField = function () { return this.textarea };\n\t\n\tTextareaInput.prototype.supportsTouch = function () { return false };\n\t\n\tTextareaInput.prototype.focus = function () {\n\t  if (this.cm.options.readOnly != \"nocursor\" && (!mobile || activeElt() != this.textarea)) {\n\t    try { this.textarea.focus() }\n\t    catch (e) {} // IE8 will throw if the textarea is display: none or not in DOM\n\t  }\n\t};\n\t\n\tTextareaInput.prototype.blur = function () { this.textarea.blur() };\n\t\n\tTextareaInput.prototype.resetPosition = function () {\n\t  this.wrapper.style.top = this.wrapper.style.left = 0\n\t};\n\t\n\tTextareaInput.prototype.receivedFocus = function () { this.slowPoll() };\n\t\n\t// Poll for input changes, using the normal rate of polling. This\n\t// runs as long as the editor is focused.\n\tTextareaInput.prototype.slowPoll = function () {\n\t    var this$1 = this;\n\t\n\t  if (this.pollingFast) { return }\n\t  this.polling.set(this.cm.options.pollInterval, function () {\n\t    this$1.poll()\n\t    if (this$1.cm.state.focused) { this$1.slowPoll() }\n\t  })\n\t};\n\t\n\t// When an event has just come in that is likely to add or change\n\t// something in the input textarea, we poll faster, to ensure that\n\t// the change appears on the screen quickly.\n\tTextareaInput.prototype.fastPoll = function () {\n\t  var missed = false, input = this\n\t  input.pollingFast = true\n\t  function p() {\n\t    var changed = input.poll()\n\t    if (!changed && !missed) {missed = true; input.polling.set(60, p)}\n\t    else {input.pollingFast = false; input.slowPoll()}\n\t  }\n\t  input.polling.set(20, p)\n\t};\n\t\n\t// Read input from the textarea, and update the document to match.\n\t// When something is selected, it is present in the textarea, and\n\t// selected (unless it is huge, in which case a placeholder is\n\t// used). When nothing is selected, the cursor sits after previously\n\t// seen text (can be empty), which is stored in prevInput (we must\n\t// not reset the textarea when typing, because that breaks IME).\n\tTextareaInput.prototype.poll = function () {\n\t    var this$1 = this;\n\t\n\t  var cm = this.cm, input = this.textarea, prevInput = this.prevInput\n\t  // Since this is called a *lot*, try to bail out as cheaply as\n\t  // possible when it is clear that nothing happened. hasSelection\n\t  // will be the case when there is a lot of text in the textarea,\n\t  // in which case reading its value would be expensive.\n\t  if (this.contextMenuPending || !cm.state.focused ||\n\t      (hasSelection(input) && !prevInput && !this.composing) ||\n\t      cm.isReadOnly() || cm.options.disableInput || cm.state.keySeq)\n\t    { return false }\n\t\n\t  var text = input.value\n\t  // If nothing changed, bail.\n\t  if (text == prevInput && !cm.somethingSelected()) { return false }\n\t  // Work around nonsensical selection resetting in IE9/10, and\n\t  // inexplicable appearance of private area unicode characters on\n\t  // some key combos in Mac (#2689).\n\t  if (ie && ie_version >= 9 && this.hasSelection === text ||\n\t      mac && /[\\uf700-\\uf7ff]/.test(text)) {\n\t    cm.display.input.reset()\n\t    return false\n\t  }\n\t\n\t  if (cm.doc.sel == cm.display.selForContextMenu) {\n\t    var first = text.charCodeAt(0)\n\t    if (first == 0x200b && !prevInput) { prevInput = \"\\u200b\" }\n\t    if (first == 0x21da) { this.reset(); return this.cm.execCommand(\"undo\") }\n\t  }\n\t  // Find the part of the input that is actually new\n\t  var same = 0, l = Math.min(prevInput.length, text.length)\n\t  while (same < l && prevInput.charCodeAt(same) == text.charCodeAt(same)) { ++same }\n\t\n\t  runInOp(cm, function () {\n\t    applyTextInput(cm, text.slice(same), prevInput.length - same,\n\t                   null, this$1.composing ? \"*compose\" : null)\n\t\n\t    // Don't leave long text in the textarea, since it makes further polling slow\n\t    if (text.length > 1000 || text.indexOf(\"\\n\") > -1) { input.value = this$1.prevInput = \"\" }\n\t    else { this$1.prevInput = text }\n\t\n\t    if (this$1.composing) {\n\t      this$1.composing.range.clear()\n\t      this$1.composing.range = cm.markText(this$1.composing.start, cm.getCursor(\"to\"),\n\t                                         {className: \"CodeMirror-composing\"})\n\t    }\n\t  })\n\t  return true\n\t};\n\t\n\tTextareaInput.prototype.ensurePolled = function () {\n\t  if (this.pollingFast && this.poll()) { this.pollingFast = false }\n\t};\n\t\n\tTextareaInput.prototype.onKeyPress = function () {\n\t  if (ie && ie_version >= 9) { this.hasSelection = null }\n\t  this.fastPoll()\n\t};\n\t\n\tTextareaInput.prototype.onContextMenu = function (e) {\n\t  var input = this, cm = input.cm, display = cm.display, te = input.textarea\n\t  var pos = posFromMouse(cm, e), scrollPos = display.scroller.scrollTop\n\t  if (!pos || presto) { return } // Opera is difficult.\n\t\n\t  // Reset the current text selection only if the click is done outside of the selection\n\t  // and 'resetSelectionOnContextMenu' option is true.\n\t  var reset = cm.options.resetSelectionOnContextMenu\n\t  if (reset && cm.doc.sel.contains(pos) == -1)\n\t    { operation(cm, setSelection)(cm.doc, simpleSelection(pos), sel_dontScroll) }\n\t\n\t  var oldCSS = te.style.cssText, oldWrapperCSS = input.wrapper.style.cssText\n\t  input.wrapper.style.cssText = \"position: absolute\"\n\t  var wrapperBox = input.wrapper.getBoundingClientRect()\n\t  te.style.cssText = \"position: absolute; width: 30px; height: 30px;\\n      top: \" + (e.clientY - wrapperBox.top - 5) + \"px; left: \" + (e.clientX - wrapperBox.left - 5) + \"px;\\n      z-index: 1000; background: \" + (ie ? \"rgba(255, 255, 255, .05)\" : \"transparent\") + \";\\n      outline: none; border-width: 0; outline: none; overflow: hidden; opacity: .05; filter: alpha(opacity=5);\"\n\t  var oldScrollY\n\t  if (webkit) { oldScrollY = window.scrollY } // Work around Chrome issue (#2712)\n\t  display.input.focus()\n\t  if (webkit) { window.scrollTo(null, oldScrollY) }\n\t  display.input.reset()\n\t  // Adds \"Select all\" to context menu in FF\n\t  if (!cm.somethingSelected()) { te.value = input.prevInput = \" \" }\n\t  input.contextMenuPending = true\n\t  display.selForContextMenu = cm.doc.sel\n\t  clearTimeout(display.detectingSelectAll)\n\t\n\t  // Select-all will be greyed out if there's nothing to select, so\n\t  // this adds a zero-width space so that we can later check whether\n\t  // it got selected.\n\t  function prepareSelectAllHack() {\n\t    if (te.selectionStart != null) {\n\t      var selected = cm.somethingSelected()\n\t      var extval = \"\\u200b\" + (selected ? te.value : \"\")\n\t      te.value = \"\\u21da\" // Used to catch context-menu undo\n\t      te.value = extval\n\t      input.prevInput = selected ? \"\" : \"\\u200b\"\n\t      te.selectionStart = 1; te.selectionEnd = extval.length\n\t      // Re-set this, in case some other handler touched the\n\t      // selection in the meantime.\n\t      display.selForContextMenu = cm.doc.sel\n\t    }\n\t  }\n\t  function rehide() {\n\t    input.contextMenuPending = false\n\t    input.wrapper.style.cssText = oldWrapperCSS\n\t    te.style.cssText = oldCSS\n\t    if (ie && ie_version < 9) { display.scrollbars.setScrollTop(display.scroller.scrollTop = scrollPos) }\n\t\n\t    // Try to detect the user choosing select-all\n\t    if (te.selectionStart != null) {\n\t      if (!ie || (ie && ie_version < 9)) { prepareSelectAllHack() }\n\t      var i = 0, poll = function () {\n\t        if (display.selForContextMenu == cm.doc.sel && te.selectionStart == 0 &&\n\t            te.selectionEnd > 0 && input.prevInput == \"\\u200b\") {\n\t          operation(cm, selectAll)(cm)\n\t        } else if (i++ < 10) {\n\t          display.detectingSelectAll = setTimeout(poll, 500)\n\t        } else {\n\t          display.selForContextMenu = null\n\t          display.input.reset()\n\t        }\n\t      }\n\t      display.detectingSelectAll = setTimeout(poll, 200)\n\t    }\n\t  }\n\t\n\t  if (ie && ie_version >= 9) { prepareSelectAllHack() }\n\t  if (captureRightClick) {\n\t    e_stop(e)\n\t    var mouseup = function () {\n\t      off(window, \"mouseup\", mouseup)\n\t      setTimeout(rehide, 20)\n\t    }\n\t    on(window, \"mouseup\", mouseup)\n\t  } else {\n\t    setTimeout(rehide, 50)\n\t  }\n\t};\n\t\n\tTextareaInput.prototype.readOnlyChanged = function (val) {\n\t  if (!val) { this.reset() }\n\t};\n\t\n\tTextareaInput.prototype.setUneditable = function () {};\n\t\n\tTextareaInput.prototype.needsContentAttribute = false\n\t\n\tfunction fromTextArea(textarea, options) {\n\t  options = options ? copyObj(options) : {}\n\t  options.value = textarea.value\n\t  if (!options.tabindex && textarea.tabIndex)\n\t    { options.tabindex = textarea.tabIndex }\n\t  if (!options.placeholder && textarea.placeholder)\n\t    { options.placeholder = textarea.placeholder }\n\t  // Set autofocus to true if this textarea is focused, or if it has\n\t  // autofocus and no other element is focused.\n\t  if (options.autofocus == null) {\n\t    var hasFocus = activeElt()\n\t    options.autofocus = hasFocus == textarea ||\n\t      textarea.getAttribute(\"autofocus\") != null && hasFocus == document.body\n\t  }\n\t\n\t  function save() {textarea.value = cm.getValue()}\n\t\n\t  var realSubmit\n\t  if (textarea.form) {\n\t    on(textarea.form, \"submit\", save)\n\t    // Deplorable hack to make the submit method do the right thing.\n\t    if (!options.leaveSubmitMethodAlone) {\n\t      var form = textarea.form\n\t      realSubmit = form.submit\n\t      try {\n\t        var wrappedSubmit = form.submit = function () {\n\t          save()\n\t          form.submit = realSubmit\n\t          form.submit()\n\t          form.submit = wrappedSubmit\n\t        }\n\t      } catch(e) {}\n\t    }\n\t  }\n\t\n\t  options.finishInit = function (cm) {\n\t    cm.save = save\n\t    cm.getTextArea = function () { return textarea; }\n\t    cm.toTextArea = function () {\n\t      cm.toTextArea = isNaN // Prevent this from being ran twice\n\t      save()\n\t      textarea.parentNode.removeChild(cm.getWrapperElement())\n\t      textarea.style.display = \"\"\n\t      if (textarea.form) {\n\t        off(textarea.form, \"submit\", save)\n\t        if (typeof textarea.form.submit == \"function\")\n\t          { textarea.form.submit = realSubmit }\n\t      }\n\t    }\n\t  }\n\t\n\t  textarea.style.display = \"none\"\n\t  var cm = CodeMirror(function (node) { return textarea.parentNode.insertBefore(node, textarea.nextSibling); },\n\t    options)\n\t  return cm\n\t}\n\t\n\tfunction addLegacyProps(CodeMirror) {\n\t  CodeMirror.off = off\n\t  CodeMirror.on = on\n\t  CodeMirror.wheelEventPixels = wheelEventPixels\n\t  CodeMirror.Doc = Doc\n\t  CodeMirror.splitLines = splitLinesAuto\n\t  CodeMirror.countColumn = countColumn\n\t  CodeMirror.findColumn = findColumn\n\t  CodeMirror.isWordChar = isWordCharBasic\n\t  CodeMirror.Pass = Pass\n\t  CodeMirror.signal = signal\n\t  CodeMirror.Line = Line\n\t  CodeMirror.changeEnd = changeEnd\n\t  CodeMirror.scrollbarModel = scrollbarModel\n\t  CodeMirror.Pos = Pos\n\t  CodeMirror.cmpPos = cmp\n\t  CodeMirror.modes = modes\n\t  CodeMirror.mimeModes = mimeModes\n\t  CodeMirror.resolveMode = resolveMode\n\t  CodeMirror.getMode = getMode\n\t  CodeMirror.modeExtensions = modeExtensions\n\t  CodeMirror.extendMode = extendMode\n\t  CodeMirror.copyState = copyState\n\t  CodeMirror.startState = startState\n\t  CodeMirror.innerMode = innerMode\n\t  CodeMirror.commands = commands\n\t  CodeMirror.keyMap = keyMap\n\t  CodeMirror.keyName = keyName\n\t  CodeMirror.isModifierKey = isModifierKey\n\t  CodeMirror.lookupKey = lookupKey\n\t  CodeMirror.normalizeKeyMap = normalizeKeyMap\n\t  CodeMirror.StringStream = StringStream\n\t  CodeMirror.SharedTextMarker = SharedTextMarker\n\t  CodeMirror.TextMarker = TextMarker\n\t  CodeMirror.LineWidget = LineWidget\n\t  CodeMirror.e_preventDefault = e_preventDefault\n\t  CodeMirror.e_stopPropagation = e_stopPropagation\n\t  CodeMirror.e_stop = e_stop\n\t  CodeMirror.addClass = addClass\n\t  CodeMirror.contains = contains\n\t  CodeMirror.rmClass = rmClass\n\t  CodeMirror.keyNames = keyNames\n\t}\n\t\n\t// EDITOR CONSTRUCTOR\n\t\n\tdefineOptions(CodeMirror)\n\t\n\taddEditorMethods(CodeMirror)\n\t\n\t// Set up methods on CodeMirror's prototype to redirect to the editor's document.\n\tvar dontDelegate = \"iter insert remove copy getEditor constructor\".split(\" \")\n\tfor (var prop in Doc.prototype) { if (Doc.prototype.hasOwnProperty(prop) && indexOf(dontDelegate, prop) < 0)\n\t  { CodeMirror.prototype[prop] = (function(method) {\n\t    return function() {return method.apply(this.doc, arguments)}\n\t  })(Doc.prototype[prop]) } }\n\t\n\teventMixin(Doc)\n\t\n\t// INPUT HANDLING\n\t\n\tCodeMirror.inputStyles = {\"textarea\": TextareaInput, \"contenteditable\": ContentEditableInput}\n\t\n\t// MODE DEFINITION AND QUERYING\n\t\n\t// Extra arguments are stored as the mode's dependencies, which is\n\t// used by (legacy) mechanisms like loadmode.js to automatically\n\t// load a mode. (Preferred mechanism is the require/define calls.)\n\tCodeMirror.defineMode = function(name/*, mode, …*/) {\n\t  if (!CodeMirror.defaults.mode && name != \"null\") { CodeMirror.defaults.mode = name }\n\t  defineMode.apply(this, arguments)\n\t}\n\t\n\tCodeMirror.defineMIME = defineMIME\n\t\n\t// Minimal default mode.\n\tCodeMirror.defineMode(\"null\", function () { return ({token: function (stream) { return stream.skipToEnd(); }}); })\n\tCodeMirror.defineMIME(\"text/plain\", \"null\")\n\t\n\t// EXTENSIONS\n\t\n\tCodeMirror.defineExtension = function (name, func) {\n\t  CodeMirror.prototype[name] = func\n\t}\n\tCodeMirror.defineDocExtension = function (name, func) {\n\t  Doc.prototype[name] = func\n\t}\n\t\n\tCodeMirror.fromTextArea = fromTextArea\n\t\n\taddLegacyProps(CodeMirror)\n\t\n\tCodeMirror.version = \"5.24.2\"\n\t\n\treturn CodeMirror;\n\t\n\t})));\n\n/***/ },\n\n/***/ 593:\n/***/ function(module, exports, __webpack_require__) {\n\n\t// CodeMirror, copyright (c) by Marijn Haverbeke and others\n\t// Distributed under an MIT license: http://codemirror.net/LICENSE\n\t\n\t(function(mod) {\n\t  if (true) // CommonJS\n\t    mod(__webpack_require__(592));\n\t  else if (typeof define == \"function\" && define.amd) // AMD\n\t    define([\"../../lib/codemirror\"], mod);\n\t  else // Plain browser env\n\t    mod(CodeMirror);\n\t})(function(CodeMirror) {\n\t  var ie_lt8 = /MSIE \\d/.test(navigator.userAgent) &&\n\t    (document.documentMode == null || document.documentMode < 8);\n\t\n\t  var Pos = CodeMirror.Pos;\n\t\n\t  var matching = {\"(\": \")>\", \")\": \"(<\", \"[\": \"]>\", \"]\": \"[<\", \"{\": \"}>\", \"}\": \"{<\"};\n\t\n\t  function findMatchingBracket(cm, where, strict, config) {\n\t    var line = cm.getLineHandle(where.line), pos = where.ch - 1;\n\t    var match = (pos >= 0 && matching[line.text.charAt(pos)]) || matching[line.text.charAt(++pos)];\n\t    if (!match) return null;\n\t    var dir = match.charAt(1) == \">\" ? 1 : -1;\n\t    if (strict && (dir > 0) != (pos == where.ch)) return null;\n\t    var style = cm.getTokenTypeAt(Pos(where.line, pos + 1));\n\t\n\t    var found = scanForBracket(cm, Pos(where.line, pos + (dir > 0 ? 1 : 0)), dir, style || null, config);\n\t    if (found == null) return null;\n\t    return {from: Pos(where.line, pos), to: found && found.pos,\n\t            match: found && found.ch == match.charAt(0), forward: dir > 0};\n\t  }\n\t\n\t  // bracketRegex is used to specify which type of bracket to scan\n\t  // should be a regexp, e.g. /[[\\]]/\n\t  //\n\t  // Note: If \"where\" is on an open bracket, then this bracket is ignored.\n\t  //\n\t  // Returns false when no bracket was found, null when it reached\n\t  // maxScanLines and gave up\n\t  function scanForBracket(cm, where, dir, style, config) {\n\t    var maxScanLen = (config && config.maxScanLineLength) || 10000;\n\t    var maxScanLines = (config && config.maxScanLines) || 1000;\n\t\n\t    var stack = [];\n\t    var re = config && config.bracketRegex ? config.bracketRegex : /[(){}[\\]]/;\n\t    var lineEnd = dir > 0 ? Math.min(where.line + maxScanLines, cm.lastLine() + 1)\n\t                          : Math.max(cm.firstLine() - 1, where.line - maxScanLines);\n\t    for (var lineNo = where.line; lineNo != lineEnd; lineNo += dir) {\n\t      var line = cm.getLine(lineNo);\n\t      if (!line) continue;\n\t      var pos = dir > 0 ? 0 : line.length - 1, end = dir > 0 ? line.length : -1;\n\t      if (line.length > maxScanLen) continue;\n\t      if (lineNo == where.line) pos = where.ch - (dir < 0 ? 1 : 0);\n\t      for (; pos != end; pos += dir) {\n\t        var ch = line.charAt(pos);\n\t        if (re.test(ch) && (style === undefined || cm.getTokenTypeAt(Pos(lineNo, pos + 1)) == style)) {\n\t          var match = matching[ch];\n\t          if ((match.charAt(1) == \">\") == (dir > 0)) stack.push(ch);\n\t          else if (!stack.length) return {pos: Pos(lineNo, pos), ch: ch};\n\t          else stack.pop();\n\t        }\n\t      }\n\t    }\n\t    return lineNo - dir == (dir > 0 ? cm.lastLine() : cm.firstLine()) ? false : null;\n\t  }\n\t\n\t  function matchBrackets(cm, autoclear, config) {\n\t    // Disable brace matching in long lines, since it'll cause hugely slow updates\n\t    var maxHighlightLen = cm.state.matchBrackets.maxHighlightLineLength || 1000;\n\t    var marks = [], ranges = cm.listSelections();\n\t    for (var i = 0; i < ranges.length; i++) {\n\t      var match = ranges[i].empty() && findMatchingBracket(cm, ranges[i].head, false, config);\n\t      if (match && cm.getLine(match.from.line).length <= maxHighlightLen) {\n\t        var style = match.match ? \"CodeMirror-matchingbracket\" : \"CodeMirror-nonmatchingbracket\";\n\t        marks.push(cm.markText(match.from, Pos(match.from.line, match.from.ch + 1), {className: style}));\n\t        if (match.to && cm.getLine(match.to.line).length <= maxHighlightLen)\n\t          marks.push(cm.markText(match.to, Pos(match.to.line, match.to.ch + 1), {className: style}));\n\t      }\n\t    }\n\t\n\t    if (marks.length) {\n\t      // Kludge to work around the IE bug from issue #1193, where text\n\t      // input stops going to the textare whever this fires.\n\t      if (ie_lt8 && cm.state.focused) cm.focus();\n\t\n\t      var clear = function() {\n\t        cm.operation(function() {\n\t          for (var i = 0; i < marks.length; i++) marks[i].clear();\n\t        });\n\t      };\n\t      if (autoclear) setTimeout(clear, 800);\n\t      else return clear;\n\t    }\n\t  }\n\t\n\t  var currentlyHighlighted = null;\n\t  function doMatchBrackets(cm) {\n\t    cm.operation(function() {\n\t      if (currentlyHighlighted) {currentlyHighlighted(); currentlyHighlighted = null;}\n\t      currentlyHighlighted = matchBrackets(cm, false, cm.state.matchBrackets);\n\t    });\n\t  }\n\t\n\t  CodeMirror.defineOption(\"matchBrackets\", false, function(cm, val, old) {\n\t    if (old && old != CodeMirror.Init) {\n\t      cm.off(\"cursorActivity\", doMatchBrackets);\n\t      if (currentlyHighlighted) {currentlyHighlighted(); currentlyHighlighted = null;}\n\t    }\n\t    if (val) {\n\t      cm.state.matchBrackets = typeof val == \"object\" ? val : {};\n\t      cm.on(\"cursorActivity\", doMatchBrackets);\n\t    }\n\t  });\n\t\n\t  CodeMirror.defineExtension(\"matchBrackets\", function() {matchBrackets(this, true);});\n\t  CodeMirror.defineExtension(\"findMatchingBracket\", function(pos, strict, config){\n\t    return findMatchingBracket(this, pos, strict, config);\n\t  });\n\t  CodeMirror.defineExtension(\"scanForBracket\", function(pos, dir, style, config){\n\t    return scanForBracket(this, pos, dir, style, config);\n\t  });\n\t});\n\n\n/***/ },\n\n/***/ 594:\n/***/ function(module, exports, __webpack_require__) {\n\n\t// CodeMirror, copyright (c) by Marijn Haverbeke and others\n\t// Distributed under an MIT license: http://codemirror.net/LICENSE\n\t\n\t(function(mod) {\n\t  if (true) // CommonJS\n\t    mod(__webpack_require__(592));\n\t  else if (typeof define == \"function\" && define.amd) // AMD\n\t    define([\"../../lib/codemirror\"], mod);\n\t  else // Plain browser env\n\t    mod(CodeMirror);\n\t})(function(CodeMirror) {\n\t  var defaults = {\n\t    pairs: \"()[]{}''\\\"\\\"\",\n\t    triples: \"\",\n\t    explode: \"[]{}\"\n\t  };\n\t\n\t  var Pos = CodeMirror.Pos;\n\t\n\t  CodeMirror.defineOption(\"autoCloseBrackets\", false, function(cm, val, old) {\n\t    if (old && old != CodeMirror.Init) {\n\t      cm.removeKeyMap(keyMap);\n\t      cm.state.closeBrackets = null;\n\t    }\n\t    if (val) {\n\t      cm.state.closeBrackets = val;\n\t      cm.addKeyMap(keyMap);\n\t    }\n\t  });\n\t\n\t  function getOption(conf, name) {\n\t    if (name == \"pairs\" && typeof conf == \"string\") return conf;\n\t    if (typeof conf == \"object\" && conf[name] != null) return conf[name];\n\t    return defaults[name];\n\t  }\n\t\n\t  var bind = defaults.pairs + \"`\";\n\t  var keyMap = {Backspace: handleBackspace, Enter: handleEnter};\n\t  for (var i = 0; i < bind.length; i++)\n\t    keyMap[\"'\" + bind.charAt(i) + \"'\"] = handler(bind.charAt(i));\n\t\n\t  function handler(ch) {\n\t    return function(cm) { return handleChar(cm, ch); };\n\t  }\n\t\n\t  function getConfig(cm) {\n\t    var deflt = cm.state.closeBrackets;\n\t    if (!deflt || deflt.override) return deflt;\n\t    var mode = cm.getModeAt(cm.getCursor());\n\t    return mode.closeBrackets || deflt;\n\t  }\n\t\n\t  function handleBackspace(cm) {\n\t    var conf = getConfig(cm);\n\t    if (!conf || cm.getOption(\"disableInput\")) return CodeMirror.Pass;\n\t\n\t    var pairs = getOption(conf, \"pairs\");\n\t    var ranges = cm.listSelections();\n\t    for (var i = 0; i < ranges.length; i++) {\n\t      if (!ranges[i].empty()) return CodeMirror.Pass;\n\t      var around = charsAround(cm, ranges[i].head);\n\t      if (!around || pairs.indexOf(around) % 2 != 0) return CodeMirror.Pass;\n\t    }\n\t    for (var i = ranges.length - 1; i >= 0; i--) {\n\t      var cur = ranges[i].head;\n\t      cm.replaceRange(\"\", Pos(cur.line, cur.ch - 1), Pos(cur.line, cur.ch + 1), \"+delete\");\n\t    }\n\t  }\n\t\n\t  function handleEnter(cm) {\n\t    var conf = getConfig(cm);\n\t    var explode = conf && getOption(conf, \"explode\");\n\t    if (!explode || cm.getOption(\"disableInput\")) return CodeMirror.Pass;\n\t\n\t    var ranges = cm.listSelections();\n\t    for (var i = 0; i < ranges.length; i++) {\n\t      if (!ranges[i].empty()) return CodeMirror.Pass;\n\t      var around = charsAround(cm, ranges[i].head);\n\t      if (!around || explode.indexOf(around) % 2 != 0) return CodeMirror.Pass;\n\t    }\n\t    cm.operation(function() {\n\t      cm.replaceSelection(\"\\n\\n\", null);\n\t      cm.execCommand(\"goCharLeft\");\n\t      ranges = cm.listSelections();\n\t      for (var i = 0; i < ranges.length; i++) {\n\t        var line = ranges[i].head.line;\n\t        cm.indentLine(line, null, true);\n\t        cm.indentLine(line + 1, null, true);\n\t      }\n\t    });\n\t  }\n\t\n\t  function contractSelection(sel) {\n\t    var inverted = CodeMirror.cmpPos(sel.anchor, sel.head) > 0;\n\t    return {anchor: new Pos(sel.anchor.line, sel.anchor.ch + (inverted ? -1 : 1)),\n\t            head: new Pos(sel.head.line, sel.head.ch + (inverted ? 1 : -1))};\n\t  }\n\t\n\t  function handleChar(cm, ch) {\n\t    var conf = getConfig(cm);\n\t    if (!conf || cm.getOption(\"disableInput\")) return CodeMirror.Pass;\n\t\n\t    var pairs = getOption(conf, \"pairs\");\n\t    var pos = pairs.indexOf(ch);\n\t    if (pos == -1) return CodeMirror.Pass;\n\t    var triples = getOption(conf, \"triples\");\n\t\n\t    var identical = pairs.charAt(pos + 1) == ch;\n\t    var ranges = cm.listSelections();\n\t    var opening = pos % 2 == 0;\n\t\n\t    var type;\n\t    for (var i = 0; i < ranges.length; i++) {\n\t      var range = ranges[i], cur = range.head, curType;\n\t      var next = cm.getRange(cur, Pos(cur.line, cur.ch + 1));\n\t      if (opening && !range.empty()) {\n\t        curType = \"surround\";\n\t      } else if ((identical || !opening) && next == ch) {\n\t        if (identical && stringStartsAfter(cm, cur))\n\t          curType = \"both\";\n\t        else if (triples.indexOf(ch) >= 0 && cm.getRange(cur, Pos(cur.line, cur.ch + 3)) == ch + ch + ch)\n\t          curType = \"skipThree\";\n\t        else\n\t          curType = \"skip\";\n\t      } else if (identical && cur.ch > 1 && triples.indexOf(ch) >= 0 &&\n\t                 cm.getRange(Pos(cur.line, cur.ch - 2), cur) == ch + ch &&\n\t                 (cur.ch <= 2 || cm.getRange(Pos(cur.line, cur.ch - 3), Pos(cur.line, cur.ch - 2)) != ch)) {\n\t        curType = \"addFour\";\n\t      } else if (identical) {\n\t        if (!CodeMirror.isWordChar(next) && enteringString(cm, cur, ch)) curType = \"both\";\n\t        else return CodeMirror.Pass;\n\t      } else if (opening && (cm.getLine(cur.line).length == cur.ch ||\n\t                             isClosingBracket(next, pairs) ||\n\t                             /\\s/.test(next))) {\n\t        curType = \"both\";\n\t      } else {\n\t        return CodeMirror.Pass;\n\t      }\n\t      if (!type) type = curType;\n\t      else if (type != curType) return CodeMirror.Pass;\n\t    }\n\t\n\t    var left = pos % 2 ? pairs.charAt(pos - 1) : ch;\n\t    var right = pos % 2 ? ch : pairs.charAt(pos + 1);\n\t    cm.operation(function() {\n\t      if (type == \"skip\") {\n\t        cm.execCommand(\"goCharRight\");\n\t      } else if (type == \"skipThree\") {\n\t        for (var i = 0; i < 3; i++)\n\t          cm.execCommand(\"goCharRight\");\n\t      } else if (type == \"surround\") {\n\t        var sels = cm.getSelections();\n\t        for (var i = 0; i < sels.length; i++)\n\t          sels[i] = left + sels[i] + right;\n\t        cm.replaceSelections(sels, \"around\");\n\t        sels = cm.listSelections().slice();\n\t        for (var i = 0; i < sels.length; i++)\n\t          sels[i] = contractSelection(sels[i]);\n\t        cm.setSelections(sels);\n\t      } else if (type == \"both\") {\n\t        cm.replaceSelection(left + right, null);\n\t        cm.triggerElectric(left + right);\n\t        cm.execCommand(\"goCharLeft\");\n\t      } else if (type == \"addFour\") {\n\t        cm.replaceSelection(left + left + left + left, \"before\");\n\t        cm.execCommand(\"goCharRight\");\n\t      }\n\t    });\n\t  }\n\t\n\t  function isClosingBracket(ch, pairs) {\n\t    var pos = pairs.lastIndexOf(ch);\n\t    return pos > -1 && pos % 2 == 1;\n\t  }\n\t\n\t  function charsAround(cm, pos) {\n\t    var str = cm.getRange(Pos(pos.line, pos.ch - 1),\n\t                          Pos(pos.line, pos.ch + 1));\n\t    return str.length == 2 ? str : null;\n\t  }\n\t\n\t  // Project the token type that will exists after the given char is\n\t  // typed, and use it to determine whether it would cause the start\n\t  // of a string token.\n\t  function enteringString(cm, pos, ch) {\n\t    var line = cm.getLine(pos.line);\n\t    var token = cm.getTokenAt(pos);\n\t    if (/\\bstring2?\\b/.test(token.type) || stringStartsAfter(cm, pos)) return false;\n\t    var stream = new CodeMirror.StringStream(line.slice(0, pos.ch) + ch + line.slice(pos.ch), 4);\n\t    stream.pos = stream.start = token.start;\n\t    for (;;) {\n\t      var type1 = cm.getMode().token(stream, token.state);\n\t      if (stream.pos >= pos.ch + 1) return /\\bstring2?\\b/.test(type1);\n\t      stream.start = stream.pos;\n\t    }\n\t  }\n\t\n\t  function stringStartsAfter(cm, pos) {\n\t    var token = cm.getTokenAt(Pos(pos.line, pos.ch + 1))\n\t    return /\\bstring/.test(token.type) && token.start == pos.ch\n\t  }\n\t});\n\n\n/***/ },\n\n/***/ 595:\n/***/ function(module, exports, __webpack_require__) {\n\n\t// CodeMirror, copyright (c) by Marijn Haverbeke and others\n\t// Distributed under an MIT license: http://codemirror.net/LICENSE\n\t\n\t(function(mod) {\n\t  if (true) // CommonJS\n\t    mod(__webpack_require__(592));\n\t  else if (typeof define == \"function\" && define.amd) // AMD\n\t    define([\"../../lib/codemirror\"], mod);\n\t  else // Plain browser env\n\t    mod(CodeMirror);\n\t})(function(CodeMirror) {\n\t\"use strict\";\n\t\n\tfunction expressionAllowed(stream, state, backUp) {\n\t  return /^(?:operator|sof|keyword c|case|new|export|default|[\\[{}\\(,;:]|=>)$/.test(state.lastType) ||\n\t    (state.lastType == \"quasi\" && /\\{\\s*$/.test(stream.string.slice(0, stream.pos - (backUp || 0))))\n\t}\n\t\n\tCodeMirror.defineMode(\"javascript\", function(config, parserConfig) {\n\t  var indentUnit = config.indentUnit;\n\t  var statementIndent = parserConfig.statementIndent;\n\t  var jsonldMode = parserConfig.jsonld;\n\t  var jsonMode = parserConfig.json || jsonldMode;\n\t  var isTS = parserConfig.typescript;\n\t  var wordRE = parserConfig.wordCharacters || /[\\w$\\xa1-\\uffff]/;\n\t\n\t  // Tokenizer\n\t\n\t  var keywords = function(){\n\t    function kw(type) {return {type: type, style: \"keyword\"};}\n\t    var A = kw(\"keyword a\"), B = kw(\"keyword b\"), C = kw(\"keyword c\");\n\t    var operator = kw(\"operator\"), atom = {type: \"atom\", style: \"atom\"};\n\t\n\t    var jsKeywords = {\n\t      \"if\": kw(\"if\"), \"while\": A, \"with\": A, \"else\": B, \"do\": B, \"try\": B, \"finally\": B,\n\t      \"return\": C, \"break\": C, \"continue\": C, \"new\": kw(\"new\"), \"delete\": C, \"throw\": C, \"debugger\": C,\n\t      \"var\": kw(\"var\"), \"const\": kw(\"var\"), \"let\": kw(\"var\"),\n\t      \"function\": kw(\"function\"), \"catch\": kw(\"catch\"),\n\t      \"for\": kw(\"for\"), \"switch\": kw(\"switch\"), \"case\": kw(\"case\"), \"default\": kw(\"default\"),\n\t      \"in\": operator, \"typeof\": operator, \"instanceof\": operator,\n\t      \"true\": atom, \"false\": atom, \"null\": atom, \"undefined\": atom, \"NaN\": atom, \"Infinity\": atom,\n\t      \"this\": kw(\"this\"), \"class\": kw(\"class\"), \"super\": kw(\"atom\"),\n\t      \"yield\": C, \"export\": kw(\"export\"), \"import\": kw(\"import\"), \"extends\": C,\n\t      \"await\": C, \"async\": kw(\"async\")\n\t    };\n\t\n\t    // Extend the 'normal' keywords with the TypeScript language extensions\n\t    if (isTS) {\n\t      var type = {type: \"variable\", style: \"variable-3\"};\n\t      var tsKeywords = {\n\t        // object-like things\n\t        \"interface\": kw(\"class\"),\n\t        \"implements\": C,\n\t        \"namespace\": C,\n\t        \"module\": kw(\"module\"),\n\t        \"enum\": kw(\"module\"),\n\t        \"type\": kw(\"type\"),\n\t\n\t        // scope modifiers\n\t        \"public\": kw(\"modifier\"),\n\t        \"private\": kw(\"modifier\"),\n\t        \"protected\": kw(\"modifier\"),\n\t        \"abstract\": kw(\"modifier\"),\n\t\n\t        // operators\n\t        \"as\": operator,\n\t\n\t        // types\n\t        \"string\": type, \"number\": type, \"boolean\": type, \"any\": type\n\t      };\n\t\n\t      for (var attr in tsKeywords) {\n\t        jsKeywords[attr] = tsKeywords[attr];\n\t      }\n\t    }\n\t\n\t    return jsKeywords;\n\t  }();\n\t\n\t  var isOperatorChar = /[+\\-*&%=<>!?|~^]/;\n\t  var isJsonldKeyword = /^@(context|id|value|language|type|container|list|set|reverse|index|base|vocab|graph)\"/;\n\t\n\t  function readRegexp(stream) {\n\t    var escaped = false, next, inSet = false;\n\t    while ((next = stream.next()) != null) {\n\t      if (!escaped) {\n\t        if (next == \"/\" && !inSet) return;\n\t        if (next == \"[\") inSet = true;\n\t        else if (inSet && next == \"]\") inSet = false;\n\t      }\n\t      escaped = !escaped && next == \"\\\\\";\n\t    }\n\t  }\n\t\n\t  // Used as scratch variables to communicate multiple values without\n\t  // consing up tons of objects.\n\t  var type, content;\n\t  function ret(tp, style, cont) {\n\t    type = tp; content = cont;\n\t    return style;\n\t  }\n\t  function tokenBase(stream, state) {\n\t    var ch = stream.next();\n\t    if (ch == '\"' || ch == \"'\") {\n\t      state.tokenize = tokenString(ch);\n\t      return state.tokenize(stream, state);\n\t    } else if (ch == \".\" && stream.match(/^\\d+(?:[eE][+\\-]?\\d+)?/)) {\n\t      return ret(\"number\", \"number\");\n\t    } else if (ch == \".\" && stream.match(\"..\")) {\n\t      return ret(\"spread\", \"meta\");\n\t    } else if (/[\\[\\]{}\\(\\),;\\:\\.]/.test(ch)) {\n\t      return ret(ch);\n\t    } else if (ch == \"=\" && stream.eat(\">\")) {\n\t      return ret(\"=>\", \"operator\");\n\t    } else if (ch == \"0\" && stream.eat(/x/i)) {\n\t      stream.eatWhile(/[\\da-f]/i);\n\t      return ret(\"number\", \"number\");\n\t    } else if (ch == \"0\" && stream.eat(/o/i)) {\n\t      stream.eatWhile(/[0-7]/i);\n\t      return ret(\"number\", \"number\");\n\t    } else if (ch == \"0\" && stream.eat(/b/i)) {\n\t      stream.eatWhile(/[01]/i);\n\t      return ret(\"number\", \"number\");\n\t    } else if (/\\d/.test(ch)) {\n\t      stream.match(/^\\d*(?:\\.\\d*)?(?:[eE][+\\-]?\\d+)?/);\n\t      return ret(\"number\", \"number\");\n\t    } else if (ch == \"/\") {\n\t      if (stream.eat(\"*\")) {\n\t        state.tokenize = tokenComment;\n\t        return tokenComment(stream, state);\n\t      } else if (stream.eat(\"/\")) {\n\t        stream.skipToEnd();\n\t        return ret(\"comment\", \"comment\");\n\t      } else if (expressionAllowed(stream, state, 1)) {\n\t        readRegexp(stream);\n\t        stream.match(/^\\b(([gimyu])(?![gimyu]*\\2))+\\b/);\n\t        return ret(\"regexp\", \"string-2\");\n\t      } else {\n\t        stream.eatWhile(isOperatorChar);\n\t        return ret(\"operator\", \"operator\", stream.current());\n\t      }\n\t    } else if (ch == \"`\") {\n\t      state.tokenize = tokenQuasi;\n\t      return tokenQuasi(stream, state);\n\t    } else if (ch == \"#\") {\n\t      stream.skipToEnd();\n\t      return ret(\"error\", \"error\");\n\t    } else if (isOperatorChar.test(ch)) {\n\t      if (ch != \">\" || !state.lexical || state.lexical.type != \">\")\n\t        stream.eatWhile(isOperatorChar);\n\t      return ret(\"operator\", \"operator\", stream.current());\n\t    } else if (wordRE.test(ch)) {\n\t      stream.eatWhile(wordRE);\n\t      var word = stream.current(), known = keywords.propertyIsEnumerable(word) && keywords[word];\n\t      return (known && state.lastType != \".\") ? ret(known.type, known.style, word) :\n\t                     ret(\"variable\", \"variable\", word);\n\t    }\n\t  }\n\t\n\t  function tokenString(quote) {\n\t    return function(stream, state) {\n\t      var escaped = false, next;\n\t      if (jsonldMode && stream.peek() == \"@\" && stream.match(isJsonldKeyword)){\n\t        state.tokenize = tokenBase;\n\t        return ret(\"jsonld-keyword\", \"meta\");\n\t      }\n\t      while ((next = stream.next()) != null) {\n\t        if (next == quote && !escaped) break;\n\t        escaped = !escaped && next == \"\\\\\";\n\t      }\n\t      if (!escaped) state.tokenize = tokenBase;\n\t      return ret(\"string\", \"string\");\n\t    };\n\t  }\n\t\n\t  function tokenComment(stream, state) {\n\t    var maybeEnd = false, ch;\n\t    while (ch = stream.next()) {\n\t      if (ch == \"/\" && maybeEnd) {\n\t        state.tokenize = tokenBase;\n\t        break;\n\t      }\n\t      maybeEnd = (ch == \"*\");\n\t    }\n\t    return ret(\"comment\", \"comment\");\n\t  }\n\t\n\t  function tokenQuasi(stream, state) {\n\t    var escaped = false, next;\n\t    while ((next = stream.next()) != null) {\n\t      if (!escaped && (next == \"`\" || next == \"$\" && stream.eat(\"{\"))) {\n\t        state.tokenize = tokenBase;\n\t        break;\n\t      }\n\t      escaped = !escaped && next == \"\\\\\";\n\t    }\n\t    return ret(\"quasi\", \"string-2\", stream.current());\n\t  }\n\t\n\t  var brackets = \"([{}])\";\n\t  // This is a crude lookahead trick to try and notice that we're\n\t  // parsing the argument patterns for a fat-arrow function before we\n\t  // actually hit the arrow token. It only works if the arrow is on\n\t  // the same line as the arguments and there's no strange noise\n\t  // (comments) in between. Fallback is to only notice when we hit the\n\t  // arrow, and not declare the arguments as locals for the arrow\n\t  // body.\n\t  function findFatArrow(stream, state) {\n\t    if (state.fatArrowAt) state.fatArrowAt = null;\n\t    var arrow = stream.string.indexOf(\"=>\", stream.start);\n\t    if (arrow < 0) return;\n\t\n\t    if (isTS) { // Try to skip TypeScript return type declarations after the arguments\n\t      var m = /:\\s*(?:\\w+(?:<[^>]*>|\\[\\])?|\\{[^}]*\\})\\s*$/.exec(stream.string.slice(stream.start, arrow))\n\t      if (m) arrow = m.index\n\t    }\n\t\n\t    var depth = 0, sawSomething = false;\n\t    for (var pos = arrow - 1; pos >= 0; --pos) {\n\t      var ch = stream.string.charAt(pos);\n\t      var bracket = brackets.indexOf(ch);\n\t      if (bracket >= 0 && bracket < 3) {\n\t        if (!depth) { ++pos; break; }\n\t        if (--depth == 0) { if (ch == \"(\") sawSomething = true; break; }\n\t      } else if (bracket >= 3 && bracket < 6) {\n\t        ++depth;\n\t      } else if (wordRE.test(ch)) {\n\t        sawSomething = true;\n\t      } else if (/[\"'\\/]/.test(ch)) {\n\t        return;\n\t      } else if (sawSomething && !depth) {\n\t        ++pos;\n\t        break;\n\t      }\n\t    }\n\t    if (sawSomething && !depth) state.fatArrowAt = pos;\n\t  }\n\t\n\t  // Parser\n\t\n\t  var atomicTypes = {\"atom\": true, \"number\": true, \"variable\": true, \"string\": true, \"regexp\": true, \"this\": true, \"jsonld-keyword\": true};\n\t\n\t  function JSLexical(indented, column, type, align, prev, info) {\n\t    this.indented = indented;\n\t    this.column = column;\n\t    this.type = type;\n\t    this.prev = prev;\n\t    this.info = info;\n\t    if (align != null) this.align = align;\n\t  }\n\t\n\t  function inScope(state, varname) {\n\t    for (var v = state.localVars; v; v = v.next)\n\t      if (v.name == varname) return true;\n\t    for (var cx = state.context; cx; cx = cx.prev) {\n\t      for (var v = cx.vars; v; v = v.next)\n\t        if (v.name == varname) return true;\n\t    }\n\t  }\n\t\n\t  function parseJS(state, style, type, content, stream) {\n\t    var cc = state.cc;\n\t    // Communicate our context to the combinators.\n\t    // (Less wasteful than consing up a hundred closures on every call.)\n\t    cx.state = state; cx.stream = stream; cx.marked = null, cx.cc = cc; cx.style = style;\n\t\n\t    if (!state.lexical.hasOwnProperty(\"align\"))\n\t      state.lexical.align = true;\n\t\n\t    while(true) {\n\t      var combinator = cc.length ? cc.pop() : jsonMode ? expression : statement;\n\t      if (combinator(type, content)) {\n\t        while(cc.length && cc[cc.length - 1].lex)\n\t          cc.pop()();\n\t        if (cx.marked) return cx.marked;\n\t        if (type == \"variable\" && inScope(state, content)) return \"variable-2\";\n\t        return style;\n\t      }\n\t    }\n\t  }\n\t\n\t  // Combinator utils\n\t\n\t  var cx = {state: null, column: null, marked: null, cc: null};\n\t  function pass() {\n\t    for (var i = arguments.length - 1; i >= 0; i--) cx.cc.push(arguments[i]);\n\t  }\n\t  function cont() {\n\t    pass.apply(null, arguments);\n\t    return true;\n\t  }\n\t  function register(varname) {\n\t    function inList(list) {\n\t      for (var v = list; v; v = v.next)\n\t        if (v.name == varname) return true;\n\t      return false;\n\t    }\n\t    var state = cx.state;\n\t    cx.marked = \"def\";\n\t    if (state.context) {\n\t      if (inList(state.localVars)) return;\n\t      state.localVars = {name: varname, next: state.localVars};\n\t    } else {\n\t      if (inList(state.globalVars)) return;\n\t      if (parserConfig.globalVars)\n\t        state.globalVars = {name: varname, next: state.globalVars};\n\t    }\n\t  }\n\t\n\t  // Combinators\n\t\n\t  var defaultVars = {name: \"this\", next: {name: \"arguments\"}};\n\t  function pushcontext() {\n\t    cx.state.context = {prev: cx.state.context, vars: cx.state.localVars};\n\t    cx.state.localVars = defaultVars;\n\t  }\n\t  function popcontext() {\n\t    cx.state.localVars = cx.state.context.vars;\n\t    cx.state.context = cx.state.context.prev;\n\t  }\n\t  function pushlex(type, info) {\n\t    var result = function() {\n\t      var state = cx.state, indent = state.indented;\n\t      if (state.lexical.type == \"stat\") indent = state.lexical.indented;\n\t      else for (var outer = state.lexical; outer && outer.type == \")\" && outer.align; outer = outer.prev)\n\t        indent = outer.indented;\n\t      state.lexical = new JSLexical(indent, cx.stream.column(), type, null, state.lexical, info);\n\t    };\n\t    result.lex = true;\n\t    return result;\n\t  }\n\t  function poplex() {\n\t    var state = cx.state;\n\t    if (state.lexical.prev) {\n\t      if (state.lexical.type == \")\")\n\t        state.indented = state.lexical.indented;\n\t      state.lexical = state.lexical.prev;\n\t    }\n\t  }\n\t  poplex.lex = true;\n\t\n\t  function expect(wanted) {\n\t    function exp(type) {\n\t      if (type == wanted) return cont();\n\t      else if (wanted == \";\") return pass();\n\t      else return cont(exp);\n\t    };\n\t    return exp;\n\t  }\n\t\n\t  function statement(type, value) {\n\t    if (type == \"var\") return cont(pushlex(\"vardef\", value.length), vardef, expect(\";\"), poplex);\n\t    if (type == \"keyword a\") return cont(pushlex(\"form\"), parenExpr, statement, poplex);\n\t    if (type == \"keyword b\") return cont(pushlex(\"form\"), statement, poplex);\n\t    if (type == \"{\") return cont(pushlex(\"}\"), block, poplex);\n\t    if (type == \";\") return cont();\n\t    if (type == \"if\") {\n\t      if (cx.state.lexical.info == \"else\" && cx.state.cc[cx.state.cc.length - 1] == poplex)\n\t        cx.state.cc.pop()();\n\t      return cont(pushlex(\"form\"), parenExpr, statement, poplex, maybeelse);\n\t    }\n\t    if (type == \"function\") return cont(functiondef);\n\t    if (type == \"for\") return cont(pushlex(\"form\"), forspec, statement, poplex);\n\t    if (type == \"variable\") return cont(pushlex(\"stat\"), maybelabel);\n\t    if (type == \"switch\") return cont(pushlex(\"form\"), parenExpr, pushlex(\"}\", \"switch\"), expect(\"{\"),\n\t                                      block, poplex, poplex);\n\t    if (type == \"case\") return cont(expression, expect(\":\"));\n\t    if (type == \"default\") return cont(expect(\":\"));\n\t    if (type == \"catch\") return cont(pushlex(\"form\"), pushcontext, expect(\"(\"), funarg, expect(\")\"),\n\t                                     statement, poplex, popcontext);\n\t    if (type == \"class\") return cont(pushlex(\"form\"), className, poplex);\n\t    if (type == \"export\") return cont(pushlex(\"stat\"), afterExport, poplex);\n\t    if (type == \"import\") return cont(pushlex(\"stat\"), afterImport, poplex);\n\t    if (type == \"module\") return cont(pushlex(\"form\"), pattern, pushlex(\"}\"), expect(\"{\"), block, poplex, poplex)\n\t    if (type == \"type\") return cont(typeexpr, expect(\"operator\"), typeexpr, expect(\";\"));\n\t    if (type == \"async\") return cont(statement)\n\t    return pass(pushlex(\"stat\"), expression, expect(\";\"), poplex);\n\t  }\n\t  function expression(type) {\n\t    return expressionInner(type, false);\n\t  }\n\t  function expressionNoComma(type) {\n\t    return expressionInner(type, true);\n\t  }\n\t  function parenExpr(type) {\n\t    if (type != \"(\") return pass()\n\t    return cont(pushlex(\")\"), expression, expect(\")\"), poplex)\n\t  }\n\t  function expressionInner(type, noComma) {\n\t    if (cx.state.fatArrowAt == cx.stream.start) {\n\t      var body = noComma ? arrowBodyNoComma : arrowBody;\n\t      if (type == \"(\") return cont(pushcontext, pushlex(\")\"), commasep(pattern, \")\"), poplex, expect(\"=>\"), body, popcontext);\n\t      else if (type == \"variable\") return pass(pushcontext, pattern, expect(\"=>\"), body, popcontext);\n\t    }\n\t\n\t    var maybeop = noComma ? maybeoperatorNoComma : maybeoperatorComma;\n\t    if (atomicTypes.hasOwnProperty(type)) return cont(maybeop);\n\t    if (type == \"function\") return cont(functiondef, maybeop);\n\t    if (type == \"class\") return cont(pushlex(\"form\"), classExpression, poplex);\n\t    if (type == \"keyword c\" || type == \"async\") return cont(noComma ? maybeexpressionNoComma : maybeexpression);\n\t    if (type == \"(\") return cont(pushlex(\")\"), maybeexpression, expect(\")\"), poplex, maybeop);\n\t    if (type == \"operator\" || type == \"spread\") return cont(noComma ? expressionNoComma : expression);\n\t    if (type == \"[\") return cont(pushlex(\"]\"), arrayLiteral, poplex, maybeop);\n\t    if (type == \"{\") return contCommasep(objprop, \"}\", null, maybeop);\n\t    if (type == \"quasi\") return pass(quasi, maybeop);\n\t    if (type == \"new\") return cont(maybeTarget(noComma));\n\t    return cont();\n\t  }\n\t  function maybeexpression(type) {\n\t    if (type.match(/[;\\}\\)\\],]/)) return pass();\n\t    return pass(expression);\n\t  }\n\t  function maybeexpressionNoComma(type) {\n\t    if (type.match(/[;\\}\\)\\],]/)) return pass();\n\t    return pass(expressionNoComma);\n\t  }\n\t\n\t  function maybeoperatorComma(type, value) {\n\t    if (type == \",\") return cont(expression);\n\t    return maybeoperatorNoComma(type, value, false);\n\t  }\n\t  function maybeoperatorNoComma(type, value, noComma) {\n\t    var me = noComma == false ? maybeoperatorComma : maybeoperatorNoComma;\n\t    var expr = noComma == false ? expression : expressionNoComma;\n\t    if (type == \"=>\") return cont(pushcontext, noComma ? arrowBodyNoComma : arrowBody, popcontext);\n\t    if (type == \"operator\") {\n\t      if (/\\+\\+|--/.test(value)) return cont(me);\n\t      if (value == \"?\") return cont(expression, expect(\":\"), expr);\n\t      return cont(expr);\n\t    }\n\t    if (type == \"quasi\") { return pass(quasi, me); }\n\t    if (type == \";\") return;\n\t    if (type == \"(\") return contCommasep(expressionNoComma, \")\", \"call\", me);\n\t    if (type == \".\") return cont(property, me);\n\t    if (type == \"[\") return cont(pushlex(\"]\"), maybeexpression, expect(\"]\"), poplex, me);\n\t  }\n\t  function quasi(type, value) {\n\t    if (type != \"quasi\") return pass();\n\t    if (value.slice(value.length - 2) != \"${\") return cont(quasi);\n\t    return cont(expression, continueQuasi);\n\t  }\n\t  function continueQuasi(type) {\n\t    if (type == \"}\") {\n\t      cx.marked = \"string-2\";\n\t      cx.state.tokenize = tokenQuasi;\n\t      return cont(quasi);\n\t    }\n\t  }\n\t  function arrowBody(type) {\n\t    findFatArrow(cx.stream, cx.state);\n\t    return pass(type == \"{\" ? statement : expression);\n\t  }\n\t  function arrowBodyNoComma(type) {\n\t    findFatArrow(cx.stream, cx.state);\n\t    return pass(type == \"{\" ? statement : expressionNoComma);\n\t  }\n\t  function maybeTarget(noComma) {\n\t    return function(type) {\n\t      if (type == \".\") return cont(noComma ? targetNoComma : target);\n\t      else return pass(noComma ? expressionNoComma : expression);\n\t    };\n\t  }\n\t  function target(_, value) {\n\t    if (value == \"target\") { cx.marked = \"keyword\"; return cont(maybeoperatorComma); }\n\t  }\n\t  function targetNoComma(_, value) {\n\t    if (value == \"target\") { cx.marked = \"keyword\"; return cont(maybeoperatorNoComma); }\n\t  }\n\t  function maybelabel(type) {\n\t    if (type == \":\") return cont(poplex, statement);\n\t    return pass(maybeoperatorComma, expect(\";\"), poplex);\n\t  }\n\t  function property(type) {\n\t    if (type == \"variable\") {cx.marked = \"property\"; return cont();}\n\t  }\n\t  function objprop(type, value) {\n\t    if (type == \"async\") {\n\t      cx.marked = \"property\";\n\t      return cont(objprop);\n\t    } else if (type == \"variable\" || cx.style == \"keyword\") {\n\t      cx.marked = \"property\";\n\t      if (value == \"get\" || value == \"set\") return cont(getterSetter);\n\t      return cont(afterprop);\n\t    } else if (type == \"number\" || type == \"string\") {\n\t      cx.marked = jsonldMode ? \"property\" : (cx.style + \" property\");\n\t      return cont(afterprop);\n\t    } else if (type == \"jsonld-keyword\") {\n\t      return cont(afterprop);\n\t    } else if (type == \"modifier\") {\n\t      return cont(objprop)\n\t    } else if (type == \"[\") {\n\t      return cont(expression, expect(\"]\"), afterprop);\n\t    } else if (type == \"spread\") {\n\t      return cont(expression);\n\t    } else if (type == \":\") {\n\t      return pass(afterprop)\n\t    }\n\t  }\n\t  function getterSetter(type) {\n\t    if (type != \"variable\") return pass(afterprop);\n\t    cx.marked = \"property\";\n\t    return cont(functiondef);\n\t  }\n\t  function afterprop(type) {\n\t    if (type == \":\") return cont(expressionNoComma);\n\t    if (type == \"(\") return pass(functiondef);\n\t  }\n\t  function commasep(what, end, sep) {\n\t    function proceed(type, value) {\n\t      if (sep ? sep.indexOf(type) > -1 : type == \",\") {\n\t        var lex = cx.state.lexical;\n\t        if (lex.info == \"call\") lex.pos = (lex.pos || 0) + 1;\n\t        return cont(function(type, value) {\n\t          if (type == end || value == end) return pass()\n\t          return pass(what)\n\t        }, proceed);\n\t      }\n\t      if (type == end || value == end) return cont();\n\t      return cont(expect(end));\n\t    }\n\t    return function(type, value) {\n\t      if (type == end || value == end) return cont();\n\t      return pass(what, proceed);\n\t    };\n\t  }\n\t  function contCommasep(what, end, info) {\n\t    for (var i = 3; i < arguments.length; i++)\n\t      cx.cc.push(arguments[i]);\n\t    return cont(pushlex(end, info), commasep(what, end), poplex);\n\t  }\n\t  function block(type) {\n\t    if (type == \"}\") return cont();\n\t    return pass(statement, block);\n\t  }\n\t  function maybetype(type, value) {\n\t    if (isTS) {\n\t      if (type == \":\") return cont(typeexpr);\n\t      if (value == \"?\") return cont(maybetype);\n\t    }\n\t  }\n\t  function typeexpr(type) {\n\t    if (type == \"variable\") {cx.marked = \"variable-3\"; return cont(afterType);}\n\t    if (type == \"string\" || type == \"number\" || type == \"atom\") return cont(afterType);\n\t    if (type == \"{\") return cont(pushlex(\"}\"), commasep(typeprop, \"}\", \",;\"), poplex)\n\t    if (type == \"(\") return cont(commasep(typearg, \")\"), maybeReturnType)\n\t  }\n\t  function maybeReturnType(type) {\n\t    if (type == \"=>\") return cont(typeexpr)\n\t  }\n\t  function typeprop(type, value) {\n\t    if (type == \"variable\" || cx.style == \"keyword\") {\n\t      cx.marked = \"property\"\n\t      return cont(typeprop)\n\t    } else if (value == \"?\") {\n\t      return cont(typeprop)\n\t    } else if (type == \":\") {\n\t      return cont(typeexpr)\n\t    }\n\t  }\n\t  function typearg(type) {\n\t    if (type == \"variable\") return cont(typearg)\n\t    else if (type == \":\") return cont(typeexpr)\n\t  }\n\t  function afterType(type, value) {\n\t    if (value == \"<\") return cont(pushlex(\">\"), commasep(typeexpr, \">\"), poplex, afterType)\n\t    if (value == \"|\" || type == \".\") return cont(typeexpr)\n\t    if (type == \"[\") return cont(expect(\"]\"), afterType)\n\t  }\n\t  function vardef() {\n\t    return pass(pattern, maybetype, maybeAssign, vardefCont);\n\t  }\n\t  function pattern(type, value) {\n\t    if (type == \"modifier\") return cont(pattern)\n\t    if (type == \"variable\") { register(value); return cont(); }\n\t    if (type == \"spread\") return cont(pattern);\n\t    if (type == \"[\") return contCommasep(pattern, \"]\");\n\t    if (type == \"{\") return contCommasep(proppattern, \"}\");\n\t  }\n\t  function proppattern(type, value) {\n\t    if (type == \"variable\" && !cx.stream.match(/^\\s*:/, false)) {\n\t      register(value);\n\t      return cont(maybeAssign);\n\t    }\n\t    if (type == \"variable\") cx.marked = \"property\";\n\t    if (type == \"spread\") return cont(pattern);\n\t    if (type == \"}\") return pass();\n\t    return cont(expect(\":\"), pattern, maybeAssign);\n\t  }\n\t  function maybeAssign(_type, value) {\n\t    if (value == \"=\") return cont(expressionNoComma);\n\t  }\n\t  function vardefCont(type) {\n\t    if (type == \",\") return cont(vardef);\n\t  }\n\t  function maybeelse(type, value) {\n\t    if (type == \"keyword b\" && value == \"else\") return cont(pushlex(\"form\", \"else\"), statement, poplex);\n\t  }\n\t  function forspec(type) {\n\t    if (type == \"(\") return cont(pushlex(\")\"), forspec1, expect(\")\"), poplex);\n\t  }\n\t  function forspec1(type) {\n\t    if (type == \"var\") return cont(vardef, expect(\";\"), forspec2);\n\t    if (type == \";\") return cont(forspec2);\n\t    if (type == \"variable\") return cont(formaybeinof);\n\t    return pass(expression, expect(\";\"), forspec2);\n\t  }\n\t  function formaybeinof(_type, value) {\n\t    if (value == \"in\" || value == \"of\") { cx.marked = \"keyword\"; return cont(expression); }\n\t    return cont(maybeoperatorComma, forspec2);\n\t  }\n\t  function forspec2(type, value) {\n\t    if (type == \";\") return cont(forspec3);\n\t    if (value == \"in\" || value == \"of\") { cx.marked = \"keyword\"; return cont(expression); }\n\t    return pass(expression, expect(\";\"), forspec3);\n\t  }\n\t  function forspec3(type) {\n\t    if (type != \")\") cont(expression);\n\t  }\n\t  function functiondef(type, value) {\n\t    if (value == \"*\") {cx.marked = \"keyword\"; return cont(functiondef);}\n\t    if (type == \"variable\") {register(value); return cont(functiondef);}\n\t    if (type == \"(\") return cont(pushcontext, pushlex(\")\"), commasep(funarg, \")\"), poplex, maybetype, statement, popcontext);\n\t  }\n\t  function funarg(type) {\n\t    if (type == \"spread\") return cont(funarg);\n\t    return pass(pattern, maybetype, maybeAssign);\n\t  }\n\t  function classExpression(type, value) {\n\t    // Class expressions may have an optional name.\n\t    if (type == \"variable\") return className(type, value);\n\t    return classNameAfter(type, value);\n\t  }\n\t  function className(type, value) {\n\t    if (type == \"variable\") {register(value); return cont(classNameAfter);}\n\t  }\n\t  function classNameAfter(type, value) {\n\t    if (value == \"extends\" || value == \"implements\" || (isTS && type == \",\"))\n\t      return cont(isTS ? typeexpr : expression, classNameAfter);\n\t    if (type == \"{\") return cont(pushlex(\"}\"), classBody, poplex);\n\t  }\n\t  function classBody(type, value) {\n\t    if (type == \"variable\" || cx.style == \"keyword\") {\n\t      if ((value == \"async\" || value == \"static\" || value == \"get\" || value == \"set\" ||\n\t           (isTS && (value == \"public\" || value == \"private\" || value == \"protected\" || value == \"readonly\" || value == \"abstract\"))) &&\n\t          cx.stream.match(/^\\s+[\\w$\\xa1-\\uffff]/, false)) {\n\t        cx.marked = \"keyword\";\n\t        return cont(classBody);\n\t      }\n\t      cx.marked = \"property\";\n\t      return cont(isTS ? classfield : functiondef, classBody);\n\t    }\n\t    if (type == \"[\")\n\t      return cont(expression, expect(\"]\"), isTS ? classfield : functiondef, classBody)\n\t    if (value == \"*\") {\n\t      cx.marked = \"keyword\";\n\t      return cont(classBody);\n\t    }\n\t    if (type == \";\") return cont(classBody);\n\t    if (type == \"}\") return cont();\n\t  }\n\t  function classfield(type, value) {\n\t    if (value == \"?\") return cont(classfield)\n\t    if (type == \":\") return cont(typeexpr, maybeAssign)\n\t    return pass(functiondef)\n\t  }\n\t  function afterExport(type, value) {\n\t    if (value == \"*\") { cx.marked = \"keyword\"; return cont(maybeFrom, expect(\";\")); }\n\t    if (value == \"default\") { cx.marked = \"keyword\"; return cont(expression, expect(\";\")); }\n\t    if (type == \"{\") return cont(commasep(exportField, \"}\"), maybeFrom, expect(\";\"));\n\t    return pass(statement);\n\t  }\n\t  function exportField(type, value) {\n\t    if (value == \"as\") { cx.marked = \"keyword\"; return cont(expect(\"variable\")); }\n\t    if (type == \"variable\") return pass(expressionNoComma, exportField);\n\t  }\n\t  function afterImport(type) {\n\t    if (type == \"string\") return cont();\n\t    return pass(importSpec, maybeMoreImports, maybeFrom);\n\t  }\n\t  function importSpec(type, value) {\n\t    if (type == \"{\") return contCommasep(importSpec, \"}\");\n\t    if (type == \"variable\") register(value);\n\t    if (value == \"*\") cx.marked = \"keyword\";\n\t    return cont(maybeAs);\n\t  }\n\t  function maybeMoreImports(type) {\n\t    if (type == \",\") return cont(importSpec, maybeMoreImports)\n\t  }\n\t  function maybeAs(_type, value) {\n\t    if (value == \"as\") { cx.marked = \"keyword\"; return cont(importSpec); }\n\t  }\n\t  function maybeFrom(_type, value) {\n\t    if (value == \"from\") { cx.marked = \"keyword\"; return cont(expression); }\n\t  }\n\t  function arrayLiteral(type) {\n\t    if (type == \"]\") return cont();\n\t    return pass(commasep(expressionNoComma, \"]\"));\n\t  }\n\t\n\t  function isContinuedStatement(state, textAfter) {\n\t    return state.lastType == \"operator\" || state.lastType == \",\" ||\n\t      isOperatorChar.test(textAfter.charAt(0)) ||\n\t      /[,.]/.test(textAfter.charAt(0));\n\t  }\n\t\n\t  // Interface\n\t\n\t  return {\n\t    startState: function(basecolumn) {\n\t      var state = {\n\t        tokenize: tokenBase,\n\t        lastType: \"sof\",\n\t        cc: [],\n\t        lexical: new JSLexical((basecolumn || 0) - indentUnit, 0, \"block\", false),\n\t        localVars: parserConfig.localVars,\n\t        context: parserConfig.localVars && {vars: parserConfig.localVars},\n\t        indented: basecolumn || 0\n\t      };\n\t      if (parserConfig.globalVars && typeof parserConfig.globalVars == \"object\")\n\t        state.globalVars = parserConfig.globalVars;\n\t      return state;\n\t    },\n\t\n\t    token: function(stream, state) {\n\t      if (stream.sol()) {\n\t        if (!state.lexical.hasOwnProperty(\"align\"))\n\t          state.lexical.align = false;\n\t        state.indented = stream.indentation();\n\t        findFatArrow(stream, state);\n\t      }\n\t      if (state.tokenize != tokenComment && stream.eatSpace()) return null;\n\t      var style = state.tokenize(stream, state);\n\t      if (type == \"comment\") return style;\n\t      state.lastType = type == \"operator\" && (content == \"++\" || content == \"--\") ? \"incdec\" : type;\n\t      return parseJS(state, style, type, content, stream);\n\t    },\n\t\n\t    indent: function(state, textAfter) {\n\t      if (state.tokenize == tokenComment) return CodeMirror.Pass;\n\t      if (state.tokenize != tokenBase) return 0;\n\t      var firstChar = textAfter && textAfter.charAt(0), lexical = state.lexical, top\n\t      // Kludge to prevent 'maybelse' from blocking lexical scope pops\n\t      if (!/^\\s*else\\b/.test(textAfter)) for (var i = state.cc.length - 1; i >= 0; --i) {\n\t        var c = state.cc[i];\n\t        if (c == poplex) lexical = lexical.prev;\n\t        else if (c != maybeelse) break;\n\t      }\n\t      while ((lexical.type == \"stat\" || lexical.type == \"form\") &&\n\t             (firstChar == \"}\" || ((top = state.cc[state.cc.length - 1]) &&\n\t                                   (top == maybeoperatorComma || top == maybeoperatorNoComma) &&\n\t                                   !/^[,\\.=+\\-*:?[\\(]/.test(textAfter))))\n\t        lexical = lexical.prev;\n\t      if (statementIndent && lexical.type == \")\" && lexical.prev.type == \"stat\")\n\t        lexical = lexical.prev;\n\t      var type = lexical.type, closing = firstChar == type;\n\t\n\t      if (type == \"vardef\") return lexical.indented + (state.lastType == \"operator\" || state.lastType == \",\" ? lexical.info + 1 : 0);\n\t      else if (type == \"form\" && firstChar == \"{\") return lexical.indented;\n\t      else if (type == \"form\") return lexical.indented + indentUnit;\n\t      else if (type == \"stat\")\n\t        return lexical.indented + (isContinuedStatement(state, textAfter) ? statementIndent || indentUnit : 0);\n\t      else if (lexical.info == \"switch\" && !closing && parserConfig.doubleIndentSwitch != false)\n\t        return lexical.indented + (/^(?:case|default)\\b/.test(textAfter) ? indentUnit : 2 * indentUnit);\n\t      else if (lexical.align) return lexical.column + (closing ? 0 : 1);\n\t      else return lexical.indented + (closing ? 0 : indentUnit);\n\t    },\n\t\n\t    electricInput: /^\\s*(?:case .*?:|default:|\\{|\\})$/,\n\t    blockCommentStart: jsonMode ? null : \"/*\",\n\t    blockCommentEnd: jsonMode ? null : \"*/\",\n\t    lineComment: jsonMode ? null : \"//\",\n\t    fold: \"brace\",\n\t    closeBrackets: \"()[]{}''\\\"\\\"``\",\n\t\n\t    helperType: jsonMode ? \"json\" : \"javascript\",\n\t    jsonldMode: jsonldMode,\n\t    jsonMode: jsonMode,\n\t\n\t    expressionAllowed: expressionAllowed,\n\t    skipExpression: function(state) {\n\t      var top = state.cc[state.cc.length - 1]\n\t      if (top == expression || top == expressionNoComma) state.cc.pop()\n\t    }\n\t  };\n\t});\n\t\n\tCodeMirror.registerHelper(\"wordChars\", \"javascript\", /[\\w$]/);\n\t\n\tCodeMirror.defineMIME(\"text/javascript\", \"javascript\");\n\tCodeMirror.defineMIME(\"text/ecmascript\", \"javascript\");\n\tCodeMirror.defineMIME(\"application/javascript\", \"javascript\");\n\tCodeMirror.defineMIME(\"application/x-javascript\", \"javascript\");\n\tCodeMirror.defineMIME(\"application/ecmascript\", \"javascript\");\n\tCodeMirror.defineMIME(\"application/json\", {name: \"javascript\", json: true});\n\tCodeMirror.defineMIME(\"application/x-json\", {name: \"javascript\", json: true});\n\tCodeMirror.defineMIME(\"application/ld+json\", {name: \"javascript\", jsonld: true});\n\tCodeMirror.defineMIME(\"text/typescript\", { name: \"javascript\", typescript: true });\n\tCodeMirror.defineMIME(\"application/typescript\", { name: \"javascript\", typescript: true });\n\t\n\t});\n\n\n/***/ },\n\n/***/ 596:\n/***/ function(module, exports) {\n\n\t\"use strict\";\n\tObject.defineProperty(exports, \"__esModule\", { value: true });\n\texports.default = {\n\t    SET_VALUE_EVENT: 'setValue'\n\t};\n\n\n/***/ },\n\n/***/ 597:\n/***/ function(module, exports, __webpack_require__) {\n\n\t\"use strict\";\n\tvar __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {\n\t    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;\n\t    if (typeof Reflect === \"object\" && typeof Reflect.decorate === \"function\") r = Reflect.decorate(decorators, target, key, desc);\n\t    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;\n\t    return c > 3 && r && Object.defineProperty(target, key, r), r;\n\t};\n\tvar __metadata = (this && this.__metadata) || function (k, v) {\n\t    if (typeof Reflect === \"object\" && typeof Reflect.metadata === \"function\") return Reflect.metadata(k, v);\n\t};\n\tvar core_1 = __webpack_require__(3);\n\tvar core_2 = __webpack_require__(3);\n\tvar scenario_1 = __webpack_require__(567);\n\tvar logical_operators_const_1 = __webpack_require__(598);\n\tvar ScenarioWizardComponent = (function () {\n\t    function ScenarioWizardComponent() {\n\t        this.onAddCriteria = new core_1.EventEmitter();\n\t        this.onRemoveCriteria = new core_1.EventEmitter();\n\t        this.onAddAction = new core_1.EventEmitter();\n\t        this.onRemoveAction = new core_1.EventEmitter();\n\t        this.LOGICAL_OPERATORS = logical_operators_const_1.default;\n\t    }\n\t    ScenarioWizardComponent.prototype.addCriteria = function () {\n\t        this.onAddCriteria.next();\n\t    };\n\t    ScenarioWizardComponent.prototype.removeCriteria = function (index) {\n\t        this.onRemoveCriteria.emit(index);\n\t    };\n\t    ScenarioWizardComponent.prototype.addAction = function () {\n\t        this.onAddAction.next();\n\t    };\n\t    ScenarioWizardComponent.prototype.removeAction = function (index) {\n\t        this.onRemoveAction.emit(index);\n\t    };\n\t    ScenarioWizardComponent.prototype.removeActionBtnVisible = function () {\n\t        return this.scenario['wizard']['actions'].length > 1;\n\t    };\n\t    __decorate([\n\t        core_2.Input(), \n\t        __metadata('design:type', (typeof (_a = typeof scenario_1.Scenario !== 'undefined' && scenario_1.Scenario) === 'function' && _a) || Object)\n\t    ], ScenarioWizardComponent.prototype, \"scenario\", void 0);\n\t    __decorate([\n\t        core_2.Output(), \n\t        __metadata('design:type', (typeof (_b = typeof core_1.EventEmitter !== 'undefined' && core_1.EventEmitter) === 'function' && _b) || Object)\n\t    ], ScenarioWizardComponent.prototype, \"onAddCriteria\", void 0);\n\t    __decorate([\n\t        core_2.Output(), \n\t        __metadata('design:type', (typeof (_c = typeof core_1.EventEmitter !== 'undefined' && core_1.EventEmitter) === 'function' && _c) || Object)\n\t    ], ScenarioWizardComponent.prototype, \"onRemoveCriteria\", void 0);\n\t    __decorate([\n\t        core_2.Output(), \n\t        __metadata('design:type', (typeof (_d = typeof core_1.EventEmitter !== 'undefined' && core_1.EventEmitter) === 'function' && _d) || Object)\n\t    ], ScenarioWizardComponent.prototype, \"onAddAction\", void 0);\n\t    __decorate([\n\t        core_2.Output(), \n\t        __metadata('design:type', (typeof (_e = typeof core_1.EventEmitter !== 'undefined' && core_1.EventEmitter) === 'function' && _e) || Object)\n\t    ], ScenarioWizardComponent.prototype, \"onRemoveAction\", void 0);\n\t    ScenarioWizardComponent = __decorate([\n\t        core_2.Component({\n\t            selector: 'sh-scenario-wizard',\n\t            template: __webpack_require__(599),\n\t            styles: [__webpack_require__(600)]\n\t        }), \n\t        __metadata('design:paramtypes', [])\n\t    ], ScenarioWizardComponent);\n\t    return ScenarioWizardComponent;\n\t    var _a, _b, _c, _d, _e;\n\t}());\n\texports.ScenarioWizardComponent = ScenarioWizardComponent;\n\n\n/***/ },\n\n/***/ 598:\n/***/ function(module, exports) {\n\n\t\"use strict\";\n\tvar operators = [\n\t    { id: 'AND', name: 'ALL' },\n\t    { id: 'OR', name: 'ANY' }\n\t];\n\tObject.defineProperty(exports, \"__esModule\", { value: true });\n\texports.default = operators;\n\n\n/***/ },\n\n/***/ 599:\n/***/ function(module, exports) {\n\n\tmodule.exports = \"<div class=\\\"row\\\">\\n    <div class=\\\"input-field col s6\\\">\\n        <label for=\\\"scenario-wizard__name\\\">Scenario Name <b class=\\\"red-text\\\">*</b></label>\\n        <input id=\\\"scenario-wizard__name\\\" type=\\\"text\\\" required\\n               class=\\\"scenario-name\\\"\\n               placeholder=\\\"Enter descriptive scenario name\\\"\\n               [(ngModel)]=\\\"scenario.name\\\"\\n               #scenarioName=\\\"ngModel\\\"/>\\n        <div [hidden]=\\\"!scenarioName.touched || scenarioName.valid\\\" class=\\\"validation-alert\\\">\\n            Scenario name should be filled\\n        </div>\\n    </div>\\n</div>\\n\\n<div class=\\\"row\\\">\\n    <div class=\\\"col\\\">\\n        <h5>\\n            If\\n            <select name=\\\"logicalOperator\\\"\\n                    class=\\\"operators-select\\\"\\n                    [(ngModel)]=\\\"scenario.wizard.logicalOperator\\\">\\n                <option *ngFor=\\\"let operator of LOGICAL_OPERATORS\\\"\\n                        [value]=\\\"operator.id\\\">{{operator.name}}\\n                </option>\\n            </select>\\n            of the conditions are true\\n        </h5>\\n\\n    </div>\\n</div>\\n<div class=\\\"row gray-bg\\\" *ngFor=\\\"let condition of scenario.wizard.conditions; let i=index\\\">\\n    <div class=\\\"col s3\\\">\\n        <label [attr.for]=\\\"'scenario-wizard__device'+i\\\">Device <b class=\\\"red-text\\\">*</b></label>\\n        <select id=\\\"scenario-wizard__device{{i}}\\\" required name=\\\"deviceSelect\\\"\\n                [(ngModel)]=\\\"condition.selectedDevice\\\">\\n            <option [value]=\\\"undefined\\\" disabled>Choose trigger</option>\\n            <option *ngFor=\\\"let device of condition.devices\\\"\\n                    [value]=\\\"device.mqttId\\\">{{device.description}}\\n            </option>\\n        </select>\\n    </div>\\n    <div class=\\\"col s4\\\">\\n        <label [attr.for]=\\\"'scenario-wizard__condition'+i\\\">Condition <b class=\\\"red-text\\\">*</b></label>\\n        <select id=\\\"scenario-wizard__condition{{i}}\\\" required name=\\\"conditionSelect\\\"\\n                [(ngModel)]=\\\"condition.selectedCondition\\\">\\n            <option [value]=\\\"undefined\\\" disabled>Choose condition</option>\\n            <option *ngFor=\\\"let condition of condition.conditions\\\" [value]=\\\"condition.id\\\">{{condition.name}}</option>\\n        </select>\\n    </div>\\n    <div class=\\\"col s3\\\">\\n        <label [attr.for]=\\\"'scenario-wizard__value'+i\\\">Value <b class=\\\"red-text\\\">*</b></label>\\n        <input id=\\\"scenario-wizard__value{{i}}\\\"\\n               type=\\\"number\\\"\\n               required\\n               #conditionValue=\\\"ngModel\\\"\\n               [(ngModel)]=\\\"condition.value\\\"\\n               placeholder=\\\"Enter value\\\"/>\\n        <div class=\\\"validation-alert\\\" [hidden]=\\\"!conditionValue.touched || conditionValue.valid\\\">\\n            Field format is incorrect\\n        </div>\\n    </div>\\n    <div class=\\\"col s1 remove-wrapper\\\"\\n         *ngIf=\\\"scenario.wizard.conditions.length>1\\\">\\n        <div class=\\\"icon-wrapper\\\">\\n            <i class=\\\"material-icons center\\\"\\n               (click)=\\\"removeCriteria(i)\\\"\\n            >delete</i>\\n        </div>\\n    </div>\\n</div>\\n<div class=\\\"row\\\">\\n    <div class=\\\"col\\\">\\n        <a (click)=\\\"addCriteria()\\\">+ ADD CRITERIA</a>\\n    </div>\\n</div>\\n<div class=\\\"row\\\">\\n    <div class=\\\"col\\\">\\n        <h5>Then do the following</h5>\\n    </div>\\n</div>\\n<div class=\\\"row gray-bg\\\" *ngFor=\\\"let action of scenario.wizard.actions; let i=index;\\\">\\n    <div class=\\\"col s3\\\">\\n        <label [attr.for]=\\\"'scenario-wizard__device'+i\\\">Device</label>\\n        <select id=\\\"scenario-wizard__device{{i}}\\\" [(ngModel)]=\\\"action.selectedDevice\\\">\\n            <option [value]=\\\"undefined\\\">Choose device</option>\\n            <option *ngFor=\\\"let device of action.devices\\\"\\n                    [value]=\\\"device.mqttId\\\">{{device.description}}\\n            </option>\\n        </select>\\n    </div>\\n    <div class=\\\"col s3\\\">\\n        <label [attr.for]=\\\"'scenario-wizard__value'+i\\\">Value</label>\\n        <select id=\\\"scenario-wizard__value{{i}}\\\" name=\\\"actionValue\\\"\\n                [(ngModel)]=\\\"action.value\\\">\\n            <option *ngFor=\\\"let value of action.values\\\"\\n                    [value]=\\\"value.id\\\">{{value.name}}\\n            </option>\\n        </select>\\n    </div>\\n    <div class=\\\"col s1 remove-wrapper\\\"\\n         *ngIf=\\\"removeActionBtnVisible()\\\">\\n        <div class=\\\"icon-wrapper\\\">\\n            <i (click)=\\\"removeAction(i)\\\" class=\\\"material-icons center\\\">delete</i>\\n        </div>\\n    </div>\\n</div>\\n\\n<div class=\\\"row\\\">\\n    <div class=\\\"col\\\">\\n        <a (click)=\\\"addAction()\\\">+ ADD ACTION</a>\\n    </div>\\n</div>\\n\"\n\n/***/ },\n\n/***/ 600:\n/***/ function(module, exports) {\n\n\tmodule.exports = \"select{display:block;border:0px solid white;padding:0px;width:auto;background-color:whitesmoke}select.condition-select{display:inline}.operators-select{display:inline;background-color:white}.gray-bg{background-color:whitesmoke}a{cursor:pointer;font-size:15px;color:#01579b}input[type=\\\"number\\\"]::-webkit-outer-spin-button,input[type=\\\"number\\\"]::-webkit-inner-spin-button{-webkit-appearance:none;margin:0}.material-icons{cursor:pointer}.icon-wrapper{position:absolute;top:50%;left:50%;transform:translate(-50%, -50%)}.remove-wrapper{height:80px;position:relative}.input-field label{position:relative;left:0;font-family:Roboto-Regular;font-size:13px}.scenario-name{margin-top:11px}\\n\"\n\n/***/ },\n\n/***/ 963:\n/***/ function(module, exports, __webpack_require__, __webpack_module_template_argument_0__) {\n\n\t/* WEBPACK VAR INJECTION */(function(process) {\n\t/**\n\t * This is the web browser implementation of `debug()`.\n\t *\n\t * Expose `debug()` as the module.\n\t */\n\t\n\texports = module.exports = __webpack_require__(__webpack_module_template_argument_0__);\n\texports.log = log;\n\texports.formatArgs = formatArgs;\n\texports.save = save;\n\texports.load = load;\n\texports.useColors = useColors;\n\texports.storage = 'undefined' != typeof chrome\n\t               && 'undefined' != typeof chrome.storage\n\t                  ? chrome.storage.local\n\t                  : localstorage();\n\t\n\t/**\n\t * Colors.\n\t */\n\t\n\texports.colors = [\n\t  'lightseagreen',\n\t  'forestgreen',\n\t  'goldenrod',\n\t  'dodgerblue',\n\t  'darkorchid',\n\t  'crimson'\n\t];\n\t\n\t/**\n\t * Currently only WebKit-based Web Inspectors, Firefox >= v31,\n\t * and the Firebug extension (any Firefox version) are known\n\t * to support \"%c\" CSS customizations.\n\t *\n\t * TODO: add a `localStorage` variable to explicitly enable/disable colors\n\t */\n\t\n\tfunction useColors() {\n\t  // is webkit? http://stackoverflow.com/a/16459606/376773\n\t  // document is undefined in react-native: https://github.com/facebook/react-native/pull/1632\n\t  return (typeof document !== 'undefined' && 'WebkitAppearance' in document.documentElement.style) ||\n\t    // is firebug? http://stackoverflow.com/a/398120/376773\n\t    (window.console && (console.firebug || (console.exception && console.table))) ||\n\t    // is firefox >= v31?\n\t    // https://developer.mozilla.org/en-US/docs/Tools/Web_Console#Styling_messages\n\t    (navigator.userAgent.toLowerCase().match(/firefox\\/(\\d+)/) && parseInt(RegExp.$1, 10) >= 31);\n\t}\n\t\n\t/**\n\t * Map %j to `JSON.stringify()`, since no Web Inspectors do that by default.\n\t */\n\t\n\texports.formatters.j = function(v) {\n\t  try {\n\t    return JSON.stringify(v);\n\t  } catch (err) {\n\t    return '[UnexpectedJSONParseError]: ' + err.message;\n\t  }\n\t};\n\t\n\t\n\t/**\n\t * Colorize log arguments if enabled.\n\t *\n\t * @api public\n\t */\n\t\n\tfunction formatArgs() {\n\t  var args = arguments;\n\t  var useColors = this.useColors;\n\t\n\t  args[0] = (useColors ? '%c' : '')\n\t    + this.namespace\n\t    + (useColors ? ' %c' : ' ')\n\t    + args[0]\n\t    + (useColors ? '%c ' : ' ')\n\t    + '+' + exports.humanize(this.diff);\n\t\n\t  if (!useColors) return args;\n\t\n\t  var c = 'color: ' + this.color;\n\t  args = [args[0], c, 'color: inherit'].concat(Array.prototype.slice.call(args, 1));\n\t\n\t  // the final \"%c\" is somewhat tricky, because there could be other\n\t  // arguments passed either before or after the %c, so we need to\n\t  // figure out the correct index to insert the CSS into\n\t  var index = 0;\n\t  var lastC = 0;\n\t  args[0].replace(/%[a-z%]/g, function(match) {\n\t    if ('%%' === match) return;\n\t    index++;\n\t    if ('%c' === match) {\n\t      // we only are interested in the *last* %c\n\t      // (the user may have provided their own)\n\t      lastC = index;\n\t    }\n\t  });\n\t\n\t  args.splice(lastC, 0, c);\n\t  return args;\n\t}\n\t\n\t/**\n\t * Invokes `console.log()` when available.\n\t * No-op when `console.log` is not a \"function\".\n\t *\n\t * @api public\n\t */\n\t\n\tfunction log() {\n\t  // this hackery is required for IE8/9, where\n\t  // the `console.log` function doesn't have 'apply'\n\t  return 'object' === typeof console\n\t    && console.log\n\t    && Function.prototype.apply.call(console.log, console, arguments);\n\t}\n\t\n\t/**\n\t * Save `namespaces`.\n\t *\n\t * @param {String} namespaces\n\t * @api private\n\t */\n\t\n\tfunction save(namespaces) {\n\t  try {\n\t    if (null == namespaces) {\n\t      exports.storage.removeItem('debug');\n\t    } else {\n\t      exports.storage.debug = namespaces;\n\t    }\n\t  } catch(e) {}\n\t}\n\t\n\t/**\n\t * Load `namespaces`.\n\t *\n\t * @return {String} returns the previously persisted debug modes\n\t * @api private\n\t */\n\t\n\tfunction load() {\n\t  var r;\n\t  try {\n\t    return exports.storage.debug;\n\t  } catch(e) {}\n\t\n\t  // If debug isn't set in LS, and we're in Electron, try to load $DEBUG\n\t  if (typeof process !== 'undefined' && 'env' in process) {\n\t    return process.env.DEBUG;\n\t  }\n\t}\n\t\n\t/**\n\t * Enable namespaces listed in `localStorage.debug` initially.\n\t */\n\t\n\texports.enable(load());\n\t\n\t/**\n\t * Localstorage attempts to return the localstorage.\n\t *\n\t * This is necessary because safari throws\n\t * when a user disables cookies/localstorage\n\t * and you attempt to access it.\n\t *\n\t * @return {LocalStorage}\n\t * @api private\n\t */\n\t\n\tfunction localstorage(){\n\t  try {\n\t    return window.localStorage;\n\t  } catch (e) {}\n\t}\n\t\n\t/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(323)))\n\n/***/ }\n\n});\n\n\n// WEBPACK FOOTER //\n// 4.4.bundle.js","import { Injectable } from '@angular/core';\n\nimport { DevicesService } from './devices.service';\nimport { Resolve } from '@angular/router';\n\n@Injectable()\nexport class DeviceListResolver implements Resolve<Object> {\n    constructor(private devicesService: DevicesService) {}\n\n    resolve() {\n        return this.devicesService.getSensors();\n    }\n}\n\n\n\n// WEBPACK FOOTER //\n// ../~/angular2-template-loader!./app/devices/devices.resolver.ts","import { Injectable } from '@angular/core';\nimport { ShHttpService } from '../core/sh-http/sh-http.service';\n\n@Injectable()\nexport class DevicesService {\n    constructor(private http: ShHttpService) { }\n\n    getSensors() {\n        return this.http.get('/sensors');\n    }\n\n    get(id = '') {\n        return this.http.get(`/sensors/${id}`);\n    }\n\n    save(sensor) {\n        return this.http.post('/sensors', sensor);\n    }\n\n    update(sensor) {\n        return this.http.put(`/sensors/${sensor._id}`, sensor);\n    }\n\n    delete(sensor) {\n        return this.http.delete(`/sensors/${sensor._id}`);\n    }\n}\n\n\n\n// WEBPACK FOOTER //\n// ../~/angular2-template-loader!./app/devices/devices.service.ts","import { NgModule } from '@angular/core';\nimport { RouterModule } from '@angular/router';\nimport { FormsModule } from '@angular/forms';\n\nimport { SharedModule } from '../shared/shared.module';\n\nimport { DeviceListComponent } from './device-list/device-list.component';\nimport { DeviceComponent } from './device/device.component';\nimport { DeviceWidgetComponent } from './device-widgets/device-widget.component';\n\nimport { DevicesService } from './devices.service';\nimport { DeviceListResolver } from './devices.resolver';\nimport { DeviceWidgetService } from './device-widgets/device-widget.service';\nimport { ServoWidgetComponent } from './device-widgets/servo-widget/servo-widget.component';\nimport { SwitcherWidgetComponent } from './device-widgets/switcher-widget/switcher-widget.component';\nimport { SensorWidgetComponent } from './device-widgets/sensor-widget/sensor-widget.component';\n\n@NgModule({\n    id: module.id,\n    imports: [\n        RouterModule,\n        FormsModule,\n        SharedModule\n    ],\n    declarations: [\n        DeviceWidgetComponent,\n        SensorWidgetComponent,\n        SwitcherWidgetComponent,\n        ServoWidgetComponent,\n        DeviceListComponent,\n        DeviceComponent\n    ],\n    exports: [\n        DeviceListComponent,\n        DeviceComponent,\n        DeviceWidgetComponent\n    ],\n    providers: [\n        DevicesService,\n        DeviceListResolver,\n        DeviceWidgetService\n    ]\n})\nexport class DevicesModule {}\n\n\n\n// WEBPACK FOOTER //\n// ../~/angular2-template-loader!./app/devices/devices.module.ts","import { Component, ViewContainerRef, Input } from '@angular/core';\nimport { Router } from '@angular/router';\n\nimport { DevicesService } from '../devices.service';\nimport { DialogService } from '../../shared/dialog/dialog.service';\nimport { Device } from '../device.model';\n\nconst headersForDisplay = [\n    { topic: 'mqttId', name: 'ID', sortable: true },\n    { topic: 'type', name: 'Type', sortable: true },\n    { topic: 'description', name: 'Description', sortable: true }\n];\n\n@Component({\n    selector: 'sh-device-list',\n    template: require('./device-list.template.html'),\n    styles: [require('./device-list.style.scss')]\n})\nexport class DeviceListComponent {\n    @Input() deviceList: Array<Device>;\n    @Input() editOnItemClick: boolean = true;\n    @Input() showDeleteButton: boolean = true;\n    @Input() statisticLink: string = '';\n\n    private sortBy = '';\n    private reverse = false;\n    private _headers = [];\n\n    constructor(\n        private devicesService: DevicesService,\n        private dialogService: DialogService,\n        private viewContainerRef: ViewContainerRef,\n        private router: Router\n    ) {\n        this._headers = headersForDisplay;\n    }\n\n    setSortBy(sortByValue) {\n        this.reverse = this.sortBy === sortByValue ? !this.reverse : false;\n        this.sortBy = sortByValue;\n\n        this.deviceList.sort((a, b) => {\n            if (a[sortByValue] < b[sortByValue]) {\n                return this.reverse ? 1 : -1;\n            }\n            if (a[sortByValue] > b[sortByValue]) {\n                return this.reverse ? -1 : 1;\n            }\n            return 0;\n        });\n    }\n\n    isActive(val) {\n        return val === this.sortBy;\n    }\n\n    getItemEditLink(id: string) {\n        return this.editOnItemClick ? ['./', id] : [];\n    }\n\n    goToDeviceStatistic(mqttId: string, type: string, $event: MouseEvent) {\n        $event.stopPropagation();\n        this.router.navigate([this.statisticLink, mqttId, 'day', type]);\n    }\n\n    removeSensor(item: Device, $event: MouseEvent) {\n        const confirmOptions = {\n            title: '',\n            message: 'Are you sure you want to delete this device?'\n        };\n\n        $event.stopPropagation();\n\n        this.dialogService.confirm(this.viewContainerRef, confirmOptions)\n            .filter(isConfirmed => isConfirmed)\n            .subscribe(() => {\n                this.devicesService\n                    .delete(item)\n                    .subscribe(data => {\n                        this.deviceList = this.deviceList.filter(elem => elem._id !== data._id);\n                    });\n            });\n    }\n\n    get headers() {\n        return this._headers;\n    }\n}\n\n\n\n// WEBPACK FOOTER //\n// ../~/angular2-template-loader!./app/devices/device-list/device-list.component.ts","module.exports = \"<div *ngIf=\\\"deviceList.length === 0\\\" class=\\\"empty-list\\\">\\n    <div class=\\\"container empty-list__container\\\">\\n        <div class=\\\"empty-list__container__text\\\">\\n            <h3 class=\\\"empty-list__container__text__main\\\">There are no devices yet</h3>\\n            <h4 class=\\\"empty-list__container__text__additional\\\">Once you connect your device to the system, it will be listed here.</h4>\\n        </div><!-- empty-list__container__text -->\\n    </div><!-- empty-list__container -->\\n</div><!-- empty-list -->\\n\\n<div *ngIf=\\\"deviceList.length !== 0\\\" class=\\\"sensors-list\\\">\\n    <table class=\\\"highlight responsive-table sensors-list-table\\\">\\n        <thead class=\\\"sensors-list-table__head\\\">\\n            <th *ngFor=\\\"let header of headers\\\"\\n                (click)=\\\"setSortBy(header.topic)\\\"\\n                class=\\\"sensors-list-table__head__item\\\"\\n                [class.active]=\\\"isActive(header.topic)\\\"\\n                [class.sortable]=\\\"header.sortable\\\">\\n                {{ header.name }}\\n                <div [class]=\\\"reverse ? 'up' : 'down'\\\"></div>\\n            </th><!-- sensors-list-table__head__item -->\\n        </thead><!-- sensors-list-table__head -->\\n        <tbody class=\\\"sensors-list-table__body\\\">\\n            <tr *ngFor=\\\"let item of deviceList\\\"\\n                [routerLink]=\\\"getItemEditLink(item._id)\\\"\\n                class=\\\"sensors-list-table__body__row\\\">\\n                <td *ngFor=\\\"let header of headers\\\"\\n                    class=\\\"sensors-list-table__body__row__item\\\">\\n                    {{item[header.topic]}}\\n                </td><!-- sensors-list-table__body__row__item -->\\n                <td *ngIf=\\\"statisticLink\\\">\\n                    <div class=\\\"sensor-widget_statistic-button\\\"\\n                        (click)=\\\"goToDeviceStatistic(item.mqttId, item.type, $event)\\\">\\n                    </div>\\n                </td>\\n                <td *ngIf=\\\"showDeleteButton\\\"\\n                    class=\\\"sensors-list-table__body__row__actions\\\">\\n                    <button (click)=\\\"removeSensor(item, $event)\\\"\\n                            class=\\\"waves-effect waves-light btn sensors-list-table__body__row__actions__remove\\\"\\n                            name=\\\"remove-device\\\"\\n                            type=\\\"remove\\\">\\n                        <i class=\\\"material-icons sensors-list-table__body__row__actions__remove__icon\\\">delete</i>\\n                    </button><!-- sensors-list-table__body__row__actions__remove -->\\n                </td><!-- sensors-list-table__body__row__actions -->\\n            </tr><!-- sensors-list-table__body__row -->\\n        </tbody><!-- sensors-list-table__body -->\\n    </table><!-- sensors-list-table -->\\n</div><!-- sensors-list -->\\n\"\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./app/devices/device-list/device-list.template.html\n// module id = 436\n// module chunks = 1 4 8 9","module.exports = \".sub-header__actions{vertical-align:middle;line-height:54px}.sensors-list-table__head__item.sortable{cursor:pointer}.sensors-list-table__head__item.sortable.active .up{width:0;height:0;border-left:5px solid transparent;border-right:5px solid transparent;border-bottom:5px solid black}.sensors-list-table__head__item.sortable.active .down{width:0;height:0;border-left:5px solid transparent;border-right:5px solid transparent;border-top:5px solid black}.sensors-list-table__body__row__actions__remove{padding:0 15px}.empty-list__container{padding:0px}.empty-list__container::before{content:'';display:block;background:url(\\\"./assets/empty-sensors-list.png\\\") no-repeat;background-size:150px;background-position:calc(100%/2);height:150px;margin:0 6px 0 0}.empty-list__container__text__main{font-family:Roboto-Regular;font-size:24px;text-align:center}.empty-list__container__text__additional{font-family:Roboto-Regular;font-size:15px;text-align:center}.sensor-widget_statistic-button{position:relative;display:block;float:left;cursor:pointer;width:24px;height:26px;margin-top:1px;background-color:#dedede;background-image:url(./assets/statistic.svg)}.sensor-widget_statistic-button:hover{box-shadow:0 2px 4px 0 rgba(0,0,0,0.5)}\\n\"\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./app/devices/device-list/device-list.style.scss\n// module id = 437\n// module chunks = 1 4 8 9","import { Component, Input } from '@angular/core';\nimport { Device } from '../device.model';\n\n@Component({\n    selector: 'sh-device',\n    template: require('./device.template.html'),\n    styles: [require('./device.style.scss')]\n})\nexport class DeviceComponent {\n    @Input() device: Device;\n\n    public switcher: boolean = false;\n\n    switchSensor(): void {\n        this.device.executor = !this.device.executor;\n    }\n\n    switcherImageUrl(): string {\n        return this.device.executor ? 'url(assets/switcherON.svg)' : 'url(assets/switcherOFF.svg)';\n    }\n}\n\n\n\n// WEBPACK FOOTER //\n// ../~/angular2-template-loader!./app/devices/device/device.component.ts","export class Device {\n    _id?: string;\n    description: string;\n    executor: boolean;\n    metrix: string;\n    mqttId: string;\n    servo: boolean;\n    type: string;\n    subType: string;\n    updateTime: string;\n    posX: Number;\n    posY: Number;\n\n    constructor(data = {}) {\n        Object.assign(this, {\n            mqttId: '',\n            type: 'servo',\n            subType: 'socket',\n            description: '',\n            executor: false,\n            sensor: false\n        }, data);\n    }\n}\n\n\n\n// WEBPACK FOOTER //\n// ../~/angular2-template-loader!./app/devices/device.model.ts","module.exports = \"<div class=\\\"device\\\">\\n    <div class=\\\"device__icon\\\"\\n         [style.background-image]=\\\"'url(assets/' + device?.subType + '.svg)'\\\">\\n    </div>\\n    <div *ngIf=\\\"device?.type === 'switcher'\\\"\\n         (click)=\\\"switchSensor()\\\">\\n        <div class=\\\"device__switcher\\\"\\n             [style.background-image]=\\\"switcherImageUrl()\\\">\\n        </div>\\n    </div>\\n</div>\\n\"\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./app/devices/device/device.template.html\n// module id = 440\n// module chunks = 1 4 8 9","module.exports = \".device{width:42px;height:42px;position:absolute;cursor:move}.device__icon{width:100%;height:100%}.device__switcher{position:absolute;left:42px;top:0;width:42px;height:42px;cursor:pointer}\\n\"\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./app/devices/device/device.style.scss\n// module id = 441\n// module chunks = 1 4 8 9","import { Component, Input, Output, EventEmitter } from '@angular/core';\n\n@Component({\n    selector: 'sh-device-widget',\n    template: require('./device-widget.template.html'),\n    styles: [require('./device-widget.style.scss')]\n})\nexport class DeviceWidgetComponent {\n    @Input() device;\n    @Input() isEditMode: boolean = false;\n    @Output() onRemoveWidget: EventEmitter<any> = new EventEmitter();\n\n    removeWidget(): void {\n        this.onRemoveWidget.emit(this.device);\n    }\n}\n\n\n\n// WEBPACK FOOTER //\n// ../~/angular2-template-loader!./app/devices/device-widgets/device-widget.component.ts","module.exports = \"<div class=\\\"sensor-widget\\\">\\n    <div class=\\\"sensor-widget_header\\\">\\n        <div class=\\\"sensor-widget_button-statistics\\\"\\n             [routerLink]=\\\"['../statistic/sensor-details', device.mqttId, 'day', device.type]\\\">\\n        </div>\\n        <div class=\\\"sensor-widget_header_info\\\">\\n            <span>{{device.description}}</span>\\n        </div>\\n        <button class=\\\"sensor-widget_button-close\\\"\\n                *ngIf=\\\"isEditMode\\\"\\n                (click)=\\\"removeWidget()\\\">\\n        </button>\\n    </div>\\n    <div>\\n        <sh-sensor-widget\\n            [device]=\\\"device\\\"\\n            *ngIf=\\\"!device.executor && !device.servo\\\">\\n        </sh-sensor-widget>\\n        <sh-switcher-widget\\n            [device]=\\\"device\\\"\\n            *ngIf=\\\"device.executor\\\">\\n        </sh-switcher-widget>\\n        <sh-servo-widget\\n            [device]=\\\"device\\\"\\n            *ngIf=\\\"device.servo\\\">\\n        </sh-servo-widget>\\n    </div>\\n</div>\\n\"\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./app/devices/device-widgets/device-widget.template.html\n// module id = 443\n// module chunks = 1 4 8 9","module.exports = \".sensor-widget{position:relative;width:182px;height:182px;padding:2px;font-family:Roboto;text-align:center;color:white;background-color:#169eb1;border:solid 1px white;overflow:hidden}.sensor-widget_footer,.sensor-widget_header{position:absolute;width:100%;bottom:0;height:27px;max-height:27px;overflow:hidden}.sensor-widget_footer{bottom:0}.sensor-widget_header{top:0;z-index:1}.sensor-widget_button-close,.sensor-widget_button-statistics{position:absolute;top:0;width:27px;height:27px;border:none;box-shadow:none;cursor:pointer;background:transparent;background-repeat:no-repeat;background-position:center;opacity:0.5}.sensor-widget_button-close:hover,.sensor-widget_button-close:active,.sensor-widget_button-close:focus,.sensor-widget_button-statistics:hover,.sensor-widget_button-statistics:active,.sensor-widget_button-statistics:focus{opacity:1}.sensor-widget_button-close{right:0;background-image:url(./assets/close-icon.svg)}.sensor-widget_button-statistics{left:0;background-image:url(./assets/statistics-icon.svg)}.sensor-widget_header_info{line-height:27px;padding:0 27px;overflow:hidden;white-space:nowrap;text-overflow:ellipsis}.sensor-widget_info{margin-top:27px;padding:27px 27px;display:table;height:100%;width:100%}.sensor-widget_info_value{display:table-cell;vertical-align:middle;text-align:center;font-size:24px;line-height:1.5;font-weight:bold;width:100%}.sensor-widget_switcher-info{padding:27px 27px;display:table;height:100%;width:100%}\\n\"\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./app/devices/device-widgets/device-widget.style.scss\n// module id = 444\n// module chunks = 1 4 8 9","import { Injectable } from '@angular/core';\nimport * as io from 'socket.io-client';\n\n@Injectable()\nexport class DeviceWidgetService {\n\n    private socket: SocketIOClient.Socket;\n    private io: SocketIOClientStatic;\n\n    constructor() {\n        this.io = io;\n        this.setupSocket();\n    }\n\n    setupSocket() {\n        this.socket = this.io.connect(ENV_PUBLIC_CONFIG.backEndWebSocketUrl);\n    }\n\n    subscribe(device, callback) {\n        if (this.socket.connected) {\n            activateDevice.apply(this);\n        } else {\n            this.socket.on('connect', () => {\n                activateDevice.apply(this);\n            });\n        }\n\n        function activateDevice() {\n            this.socket.on('event', callback);\n\n            if (!device) {\n                return;\n            }\n            this.socket.emit('subscribe', {device});\n        }\n    }\n\n    unsubscribe(device) {\n        this.socket.emit('unsubscribe', {device});\n    }\n\n    pushEvent(config) {\n        this.socket.emit('pushEvent', config);\n    }\n}\n\n\n\n// WEBPACK FOOTER //\n// ../~/angular2-template-loader!./app/devices/device-widgets/device-widget.service.ts","\n/**\n * Module dependencies.\n */\n\nvar url = require('./url');\nvar parser = require('socket.io-parser');\nvar Manager = require('./manager');\nvar debug = require('debug')('socket.io-client');\n\n/**\n * Module exports.\n */\n\nmodule.exports = exports = lookup;\n\n/**\n * Managers cache.\n */\n\nvar cache = exports.managers = {};\n\n/**\n * Looks up an existing `Manager` for multiplexing.\n * If the user summons:\n *\n *   `io('http://localhost/a');`\n *   `io('http://localhost/b');`\n *\n * We reuse the existing instance based on same scheme/port/host,\n * and we initialize sockets for each namespace.\n *\n * @api public\n */\n\nfunction lookup (uri, opts) {\n  if (typeof uri === 'object') {\n    opts = uri;\n    uri = undefined;\n  }\n\n  opts = opts || {};\n\n  var parsed = url(uri);\n  var source = parsed.source;\n  var id = parsed.id;\n  var path = parsed.path;\n  var sameNamespace = cache[id] && path in cache[id].nsps;\n  var newConnection = opts.forceNew || opts['force new connection'] ||\n                      false === opts.multiplex || sameNamespace;\n\n  var io;\n\n  if (newConnection) {\n    debug('ignoring socket cache for %s', source);\n    io = Manager(source, opts);\n  } else {\n    if (!cache[id]) {\n      debug('new io instance for %s', source);\n      cache[id] = Manager(source, opts);\n    }\n    io = cache[id];\n  }\n  if (parsed.query && !opts.query) {\n    opts.query = parsed.query;\n  } else if (opts && 'object' === typeof opts.query) {\n    opts.query = encodeQueryString(opts.query);\n  }\n  return io.socket(parsed.path, opts);\n}\n/**\n *  Helper method to parse query objects to string.\n * @param {object} query\n * @returns {string}\n */\nfunction encodeQueryString (obj) {\n  var str = [];\n  for (var p in obj) {\n    if (obj.hasOwnProperty(p)) {\n      str.push(encodeURIComponent(p) + '=' + encodeURIComponent(obj[p]));\n    }\n  }\n  return str.join('&');\n}\n/**\n * Protocol version.\n *\n * @api public\n */\n\nexports.protocol = parser.protocol;\n\n/**\n * `connect`.\n *\n * @param {String} uri\n * @api public\n */\n\nexports.connect = lookup;\n\n/**\n * Expose constructors for standalone build.\n *\n * @api public\n */\n\nexports.Manager = require('./manager');\nexports.Socket = require('./socket');\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ../~/socket.io-client/lib/index.js\n// module id = 446\n// module chunks = 1 4 8 9 11","\n/**\n * Module dependencies.\n */\n\nvar parseuri = require('parseuri');\nvar debug = require('debug')('socket.io-client:url');\n\n/**\n * Module exports.\n */\n\nmodule.exports = url;\n\n/**\n * URL parser.\n *\n * @param {String} url\n * @param {Object} An object meant to mimic window.location.\n *                 Defaults to window.location.\n * @api public\n */\n\nfunction url (uri, loc) {\n  var obj = uri;\n\n  // default to window.location\n  loc = loc || global.location;\n  if (null == uri) uri = loc.protocol + '//' + loc.host;\n\n  // relative path support\n  if ('string' === typeof uri) {\n    if ('/' === uri.charAt(0)) {\n      if ('/' === uri.charAt(1)) {\n        uri = loc.protocol + uri;\n      } else {\n        uri = loc.host + uri;\n      }\n    }\n\n    if (!/^(https?|wss?):\\/\\//.test(uri)) {\n      debug('protocol-less url %s', uri);\n      if ('undefined' !== typeof loc) {\n        uri = loc.protocol + '//' + uri;\n      } else {\n        uri = 'https://' + uri;\n      }\n    }\n\n    // parse\n    debug('parse %s', uri);\n    obj = parseuri(uri);\n  }\n\n  // make sure we treat `localhost:80` and `localhost` equally\n  if (!obj.port) {\n    if (/^(http|ws)$/.test(obj.protocol)) {\n      obj.port = '80';\n    } else if (/^(http|ws)s$/.test(obj.protocol)) {\n      obj.port = '443';\n    }\n  }\n\n  obj.path = obj.path || '/';\n\n  var ipv6 = obj.host.indexOf(':') !== -1;\n  var host = ipv6 ? '[' + obj.host + ']' : obj.host;\n\n  // define unique id\n  obj.id = obj.protocol + '://' + host + ':' + obj.port;\n  // define href\n  obj.href = obj.protocol + '://' + host + (loc && loc.port === obj.port ? '' : (':' + obj.port));\n\n  return obj;\n}\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ../~/socket.io-client/lib/url.js\n// module id = 447\n// module chunks = 1 4 8 9 11","/**\r\n * Parses an URI\r\n *\r\n * @author Steven Levithan <stevenlevithan.com> (MIT license)\r\n * @api private\r\n */\r\n\r\nvar re = /^(?:(?![^:@]+:[^:@\\/]*@)(http|https|ws|wss):\\/\\/)?((?:(([^:@]*)(?::([^:@]*))?)?@)?((?:[a-f0-9]{0,4}:){2,7}[a-f0-9]{0,4}|[^:\\/?#]*)(?::(\\d*))?)(((\\/(?:[^?#](?![^?#\\/]*\\.[^?#\\/.]+(?:[?#]|$)))*\\/?)?([^?#\\/]*))(?:\\?([^#]*))?(?:#(.*))?)/;\r\n\r\nvar parts = [\r\n    'source', 'protocol', 'authority', 'userInfo', 'user', 'password', 'host', 'port', 'relative', 'path', 'directory', 'file', 'query', 'anchor'\r\n];\r\n\r\nmodule.exports = function parseuri(str) {\r\n    var src = str,\r\n        b = str.indexOf('['),\r\n        e = str.indexOf(']');\r\n\r\n    if (b != -1 && e != -1) {\r\n        str = str.substring(0, b) + str.substring(b, e).replace(/:/g, ';') + str.substring(e, str.length);\r\n    }\r\n\r\n    var m = re.exec(str || ''),\r\n        uri = {},\r\n        i = 14;\r\n\r\n    while (i--) {\r\n        uri[parts[i]] = m[i] || '';\r\n    }\r\n\r\n    if (b != -1 && e != -1) {\r\n        uri.source = src;\r\n        uri.host = uri.host.substring(1, uri.host.length - 1).replace(/;/g, ':');\r\n        uri.authority = uri.authority.replace('[', '').replace(']', '').replace(/;/g, ':');\r\n        uri.ipv6uri = true;\r\n    }\r\n\r\n    return uri;\r\n};\r\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ../~/parseuri/index.js\n// module id = 448\n// module chunks = 1 4 8 9 11","\n/**\n * This is the common logic for both the Node.js and web browser\n * implementations of `debug()`.\n *\n * Expose `debug()` as the module.\n */\n\nexports = module.exports = debug.debug = debug;\nexports.coerce = coerce;\nexports.disable = disable;\nexports.enable = enable;\nexports.enabled = enabled;\nexports.humanize = require('ms');\n\n/**\n * The currently active debug mode names, and names to skip.\n */\n\nexports.names = [];\nexports.skips = [];\n\n/**\n * Map of special \"%n\" handling functions, for the debug \"format\" argument.\n *\n * Valid key names are a single, lowercased letter, i.e. \"n\".\n */\n\nexports.formatters = {};\n\n/**\n * Previously assigned color.\n */\n\nvar prevColor = 0;\n\n/**\n * Previous log timestamp.\n */\n\nvar prevTime;\n\n/**\n * Select a color.\n *\n * @return {Number}\n * @api private\n */\n\nfunction selectColor() {\n  return exports.colors[prevColor++ % exports.colors.length];\n}\n\n/**\n * Create a debugger with the given `namespace`.\n *\n * @param {String} namespace\n * @return {Function}\n * @api public\n */\n\nfunction debug(namespace) {\n\n  // define the `disabled` version\n  function disabled() {\n  }\n  disabled.enabled = false;\n\n  // define the `enabled` version\n  function enabled() {\n\n    var self = enabled;\n\n    // set `diff` timestamp\n    var curr = +new Date();\n    var ms = curr - (prevTime || curr);\n    self.diff = ms;\n    self.prev = prevTime;\n    self.curr = curr;\n    prevTime = curr;\n\n    // add the `color` if not set\n    if (null == self.useColors) self.useColors = exports.useColors();\n    if (null == self.color && self.useColors) self.color = selectColor();\n\n    var args = new Array(arguments.length);\n    for (var i = 0; i < args.length; i++) {\n      args[i] = arguments[i];\n    }\n\n    args[0] = exports.coerce(args[0]);\n\n    if ('string' !== typeof args[0]) {\n      // anything else let's inspect with %o\n      args = ['%o'].concat(args);\n    }\n\n    // apply any `formatters` transformations\n    var index = 0;\n    args[0] = args[0].replace(/%([a-z%])/g, function(match, format) {\n      // if we encounter an escaped % then don't increase the array index\n      if (match === '%%') return match;\n      index++;\n      var formatter = exports.formatters[format];\n      if ('function' === typeof formatter) {\n        var val = args[index];\n        match = formatter.call(self, val);\n\n        // now we need to remove `args[index]` since it's inlined in the `format`\n        args.splice(index, 1);\n        index--;\n      }\n      return match;\n    });\n\n    // apply env-specific formatting\n    args = exports.formatArgs.apply(self, args);\n\n    var logFn = enabled.log || exports.log || console.log.bind(console);\n    logFn.apply(self, args);\n  }\n  enabled.enabled = true;\n\n  var fn = exports.enabled(namespace) ? enabled : disabled;\n\n  fn.namespace = namespace;\n\n  return fn;\n}\n\n/**\n * Enables a debug mode by namespaces. This can include modes\n * separated by a colon and wildcards.\n *\n * @param {String} namespaces\n * @api public\n */\n\nfunction enable(namespaces) {\n  exports.save(namespaces);\n\n  var split = (namespaces || '').split(/[\\s,]+/);\n  var len = split.length;\n\n  for (var i = 0; i < len; i++) {\n    if (!split[i]) continue; // ignore empty strings\n    namespaces = split[i].replace(/[\\\\^$+?.()|[\\]{}]/g, '\\\\$&').replace(/\\*/g, '.*?');\n    if (namespaces[0] === '-') {\n      exports.skips.push(new RegExp('^' + namespaces.substr(1) + '$'));\n    } else {\n      exports.names.push(new RegExp('^' + namespaces + '$'));\n    }\n  }\n}\n\n/**\n * Disable debug output.\n *\n * @api public\n */\n\nfunction disable() {\n  exports.enable('');\n}\n\n/**\n * Returns true if the given mode name is enabled, false otherwise.\n *\n * @param {String} name\n * @return {Boolean}\n * @api public\n */\n\nfunction enabled(name) {\n  var i, len;\n  for (i = 0, len = exports.skips.length; i < len; i++) {\n    if (exports.skips[i].test(name)) {\n      return false;\n    }\n  }\n  for (i = 0, len = exports.names.length; i < len; i++) {\n    if (exports.names[i].test(name)) {\n      return true;\n    }\n  }\n  return false;\n}\n\n/**\n * Coerce `val`.\n *\n * @param {Mixed} val\n * @return {Mixed}\n * @api private\n */\n\nfunction coerce(val) {\n  if (val instanceof Error) return val.stack || val.message;\n  return val;\n}\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ../~/socket.io-client/~/debug/debug.js\n// module id = 450\n// module chunks = 1 4 8 9 11","/**\n * Helpers.\n */\n\nvar s = 1000\nvar m = s * 60\nvar h = m * 60\nvar d = h * 24\nvar y = d * 365.25\n\n/**\n * Parse or format the given `val`.\n *\n * Options:\n *\n *  - `long` verbose formatting [false]\n *\n * @param {String|Number} val\n * @param {Object} options\n * @throws {Error} throw an error if val is not a non-empty string or a number\n * @return {String|Number}\n * @api public\n */\n\nmodule.exports = function (val, options) {\n  options = options || {}\n  var type = typeof val\n  if (type === 'string' && val.length > 0) {\n    return parse(val)\n  } else if (type === 'number' && isNaN(val) === false) {\n    return options.long ?\n\t\t\tfmtLong(val) :\n\t\t\tfmtShort(val)\n  }\n  throw new Error('val is not a non-empty string or a valid number. val=' + JSON.stringify(val))\n}\n\n/**\n * Parse the given `str` and return milliseconds.\n *\n * @param {String} str\n * @return {Number}\n * @api private\n */\n\nfunction parse(str) {\n  str = String(str)\n  if (str.length > 10000) {\n    return\n  }\n  var match = /^((?:\\d+)?\\.?\\d+) *(milliseconds?|msecs?|ms|seconds?|secs?|s|minutes?|mins?|m|hours?|hrs?|h|days?|d|years?|yrs?|y)?$/i.exec(str)\n  if (!match) {\n    return\n  }\n  var n = parseFloat(match[1])\n  var type = (match[2] || 'ms').toLowerCase()\n  switch (type) {\n    case 'years':\n    case 'year':\n    case 'yrs':\n    case 'yr':\n    case 'y':\n      return n * y\n    case 'days':\n    case 'day':\n    case 'd':\n      return n * d\n    case 'hours':\n    case 'hour':\n    case 'hrs':\n    case 'hr':\n    case 'h':\n      return n * h\n    case 'minutes':\n    case 'minute':\n    case 'mins':\n    case 'min':\n    case 'm':\n      return n * m\n    case 'seconds':\n    case 'second':\n    case 'secs':\n    case 'sec':\n    case 's':\n      return n * s\n    case 'milliseconds':\n    case 'millisecond':\n    case 'msecs':\n    case 'msec':\n    case 'ms':\n      return n\n    default:\n      return undefined\n  }\n}\n\n/**\n * Short format for `ms`.\n *\n * @param {Number} ms\n * @return {String}\n * @api private\n */\n\nfunction fmtShort(ms) {\n  if (ms >= d) {\n    return Math.round(ms / d) + 'd'\n  }\n  if (ms >= h) {\n    return Math.round(ms / h) + 'h'\n  }\n  if (ms >= m) {\n    return Math.round(ms / m) + 'm'\n  }\n  if (ms >= s) {\n    return Math.round(ms / s) + 's'\n  }\n  return ms + 'ms'\n}\n\n/**\n * Long format for `ms`.\n *\n * @param {Number} ms\n * @return {String}\n * @api private\n */\n\nfunction fmtLong(ms) {\n  return plural(ms, d, 'day') ||\n    plural(ms, h, 'hour') ||\n    plural(ms, m, 'minute') ||\n    plural(ms, s, 'second') ||\n    ms + ' ms'\n}\n\n/**\n * Pluralization helper.\n */\n\nfunction plural(ms, n, name) {\n  if (ms < n) {\n    return\n  }\n  if (ms < n * 1.5) {\n    return Math.floor(ms / n) + ' ' + name\n  }\n  return Math.ceil(ms / n) + ' ' + name + 's'\n}\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ../~/ms/index.js\n// module id = 451\n// module chunks = 1 4 8 9 11","\n/**\n * Module dependencies.\n */\n\nvar debug = require('debug')('socket.io-parser');\nvar json = require('json3');\nvar Emitter = require('component-emitter');\nvar binary = require('./binary');\nvar isBuf = require('./is-buffer');\n\n/**\n * Protocol version.\n *\n * @api public\n */\n\nexports.protocol = 4;\n\n/**\n * Packet types.\n *\n * @api public\n */\n\nexports.types = [\n  'CONNECT',\n  'DISCONNECT',\n  'EVENT',\n  'ACK',\n  'ERROR',\n  'BINARY_EVENT',\n  'BINARY_ACK'\n];\n\n/**\n * Packet type `connect`.\n *\n * @api public\n */\n\nexports.CONNECT = 0;\n\n/**\n * Packet type `disconnect`.\n *\n * @api public\n */\n\nexports.DISCONNECT = 1;\n\n/**\n * Packet type `event`.\n *\n * @api public\n */\n\nexports.EVENT = 2;\n\n/**\n * Packet type `ack`.\n *\n * @api public\n */\n\nexports.ACK = 3;\n\n/**\n * Packet type `error`.\n *\n * @api public\n */\n\nexports.ERROR = 4;\n\n/**\n * Packet type 'binary event'\n *\n * @api public\n */\n\nexports.BINARY_EVENT = 5;\n\n/**\n * Packet type `binary ack`. For acks with binary arguments.\n *\n * @api public\n */\n\nexports.BINARY_ACK = 6;\n\n/**\n * Encoder constructor.\n *\n * @api public\n */\n\nexports.Encoder = Encoder;\n\n/**\n * Decoder constructor.\n *\n * @api public\n */\n\nexports.Decoder = Decoder;\n\n/**\n * A socket.io Encoder instance\n *\n * @api public\n */\n\nfunction Encoder() {}\n\n/**\n * Encode a packet as a single string if non-binary, or as a\n * buffer sequence, depending on packet type.\n *\n * @param {Object} obj - packet object\n * @param {Function} callback - function to handle encodings (likely engine.write)\n * @return Calls callback with Array of encodings\n * @api public\n */\n\nEncoder.prototype.encode = function(obj, callback){\n  debug('encoding packet %j', obj);\n\n  if (exports.BINARY_EVENT == obj.type || exports.BINARY_ACK == obj.type) {\n    encodeAsBinary(obj, callback);\n  }\n  else {\n    var encoding = encodeAsString(obj);\n    callback([encoding]);\n  }\n};\n\n/**\n * Encode packet as string.\n *\n * @param {Object} packet\n * @return {String} encoded\n * @api private\n */\n\nfunction encodeAsString(obj) {\n  var str = '';\n  var nsp = false;\n\n  // first is type\n  str += obj.type;\n\n  // attachments if we have them\n  if (exports.BINARY_EVENT == obj.type || exports.BINARY_ACK == obj.type) {\n    str += obj.attachments;\n    str += '-';\n  }\n\n  // if we have a namespace other than `/`\n  // we append it followed by a comma `,`\n  if (obj.nsp && '/' != obj.nsp) {\n    nsp = true;\n    str += obj.nsp;\n  }\n\n  // immediately followed by the id\n  if (null != obj.id) {\n    if (nsp) {\n      str += ',';\n      nsp = false;\n    }\n    str += obj.id;\n  }\n\n  // json data\n  if (null != obj.data) {\n    if (nsp) str += ',';\n    str += json.stringify(obj.data);\n  }\n\n  debug('encoded %j as %s', obj, str);\n  return str;\n}\n\n/**\n * Encode packet as 'buffer sequence' by removing blobs, and\n * deconstructing packet into object with placeholders and\n * a list of buffers.\n *\n * @param {Object} packet\n * @return {Buffer} encoded\n * @api private\n */\n\nfunction encodeAsBinary(obj, callback) {\n\n  function writeEncoding(bloblessData) {\n    var deconstruction = binary.deconstructPacket(bloblessData);\n    var pack = encodeAsString(deconstruction.packet);\n    var buffers = deconstruction.buffers;\n\n    buffers.unshift(pack); // add packet info to beginning of data list\n    callback(buffers); // write all the buffers\n  }\n\n  binary.removeBlobs(obj, writeEncoding);\n}\n\n/**\n * A socket.io Decoder instance\n *\n * @return {Object} decoder\n * @api public\n */\n\nfunction Decoder() {\n  this.reconstructor = null;\n}\n\n/**\n * Mix in `Emitter` with Decoder.\n */\n\nEmitter(Decoder.prototype);\n\n/**\n * Decodes an ecoded packet string into packet JSON.\n *\n * @param {String} obj - encoded packet\n * @return {Object} packet\n * @api public\n */\n\nDecoder.prototype.add = function(obj) {\n  var packet;\n  if ('string' == typeof obj) {\n    packet = decodeString(obj);\n    if (exports.BINARY_EVENT == packet.type || exports.BINARY_ACK == packet.type) { // binary packet's json\n      this.reconstructor = new BinaryReconstructor(packet);\n\n      // no attachments, labeled binary but no binary data to follow\n      if (this.reconstructor.reconPack.attachments === 0) {\n        this.emit('decoded', packet);\n      }\n    } else { // non-binary full packet\n      this.emit('decoded', packet);\n    }\n  }\n  else if (isBuf(obj) || obj.base64) { // raw binary data\n    if (!this.reconstructor) {\n      throw new Error('got binary data when not reconstructing a packet');\n    } else {\n      packet = this.reconstructor.takeBinaryData(obj);\n      if (packet) { // received final buffer\n        this.reconstructor = null;\n        this.emit('decoded', packet);\n      }\n    }\n  }\n  else {\n    throw new Error('Unknown type: ' + obj);\n  }\n};\n\n/**\n * Decode a packet String (JSON data)\n *\n * @param {String} str\n * @return {Object} packet\n * @api private\n */\n\nfunction decodeString(str) {\n  var p = {};\n  var i = 0;\n\n  // look up type\n  p.type = Number(str.charAt(0));\n  if (null == exports.types[p.type]) return error();\n\n  // look up attachments if type binary\n  if (exports.BINARY_EVENT == p.type || exports.BINARY_ACK == p.type) {\n    var buf = '';\n    while (str.charAt(++i) != '-') {\n      buf += str.charAt(i);\n      if (i == str.length) break;\n    }\n    if (buf != Number(buf) || str.charAt(i) != '-') {\n      throw new Error('Illegal attachments');\n    }\n    p.attachments = Number(buf);\n  }\n\n  // look up namespace (if any)\n  if ('/' == str.charAt(i + 1)) {\n    p.nsp = '';\n    while (++i) {\n      var c = str.charAt(i);\n      if (',' == c) break;\n      p.nsp += c;\n      if (i == str.length) break;\n    }\n  } else {\n    p.nsp = '/';\n  }\n\n  // look up id\n  var next = str.charAt(i + 1);\n  if ('' !== next && Number(next) == next) {\n    p.id = '';\n    while (++i) {\n      var c = str.charAt(i);\n      if (null == c || Number(c) != c) {\n        --i;\n        break;\n      }\n      p.id += str.charAt(i);\n      if (i == str.length) break;\n    }\n    p.id = Number(p.id);\n  }\n\n  // look up json data\n  if (str.charAt(++i)) {\n    p = tryParse(p, str.substr(i));\n  }\n\n  debug('decoded %s as %j', str, p);\n  return p;\n}\n\nfunction tryParse(p, str) {\n  try {\n    p.data = json.parse(str);\n  } catch(e){\n    return error();\n  }\n  return p; \n};\n\n/**\n * Deallocates a parser's resources\n *\n * @api public\n */\n\nDecoder.prototype.destroy = function() {\n  if (this.reconstructor) {\n    this.reconstructor.finishedReconstruction();\n  }\n};\n\n/**\n * A manager of a binary event's 'buffer sequence'. Should\n * be constructed whenever a packet of type BINARY_EVENT is\n * decoded.\n *\n * @param {Object} packet\n * @return {BinaryReconstructor} initialized reconstructor\n * @api private\n */\n\nfunction BinaryReconstructor(packet) {\n  this.reconPack = packet;\n  this.buffers = [];\n}\n\n/**\n * Method to be called when binary data received from connection\n * after a BINARY_EVENT packet.\n *\n * @param {Buffer | ArrayBuffer} binData - the raw binary data received\n * @return {null | Object} returns null if more binary data is expected or\n *   a reconstructed packet object if all buffers have been received.\n * @api private\n */\n\nBinaryReconstructor.prototype.takeBinaryData = function(binData) {\n  this.buffers.push(binData);\n  if (this.buffers.length == this.reconPack.attachments) { // done with buffer list\n    var packet = binary.reconstructPacket(this.reconPack, this.buffers);\n    this.finishedReconstruction();\n    return packet;\n  }\n  return null;\n};\n\n/**\n * Cleans up binary packet reconstruction variables.\n *\n * @api private\n */\n\nBinaryReconstructor.prototype.finishedReconstruction = function() {\n  this.reconPack = null;\n  this.buffers = [];\n};\n\nfunction error(data){\n  return {\n    type: exports.ERROR,\n    data: 'parser error'\n  };\n}\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ../~/socket.io-parser/index.js\n// module id = 452\n// module chunks = 1 4 8 9 11","\n/**\n * This is the web browser implementation of `debug()`.\n *\n * Expose `debug()` as the module.\n */\n\nexports = module.exports = require('./debug');\nexports.log = log;\nexports.formatArgs = formatArgs;\nexports.save = save;\nexports.load = load;\nexports.useColors = useColors;\nexports.storage = 'undefined' != typeof chrome\n               && 'undefined' != typeof chrome.storage\n                  ? chrome.storage.local\n                  : localstorage();\n\n/**\n * Colors.\n */\n\nexports.colors = [\n  'lightseagreen',\n  'forestgreen',\n  'goldenrod',\n  'dodgerblue',\n  'darkorchid',\n  'crimson'\n];\n\n/**\n * Currently only WebKit-based Web Inspectors, Firefox >= v31,\n * and the Firebug extension (any Firefox version) are known\n * to support \"%c\" CSS customizations.\n *\n * TODO: add a `localStorage` variable to explicitly enable/disable colors\n */\n\nfunction useColors() {\n  // is webkit? http://stackoverflow.com/a/16459606/376773\n  return ('WebkitAppearance' in document.documentElement.style) ||\n    // is firebug? http://stackoverflow.com/a/398120/376773\n    (window.console && (console.firebug || (console.exception && console.table))) ||\n    // is firefox >= v31?\n    // https://developer.mozilla.org/en-US/docs/Tools/Web_Console#Styling_messages\n    (navigator.userAgent.toLowerCase().match(/firefox\\/(\\d+)/) && parseInt(RegExp.$1, 10) >= 31);\n}\n\n/**\n * Map %j to `JSON.stringify()`, since no Web Inspectors do that by default.\n */\n\nexports.formatters.j = function(v) {\n  return JSON.stringify(v);\n};\n\n\n/**\n * Colorize log arguments if enabled.\n *\n * @api public\n */\n\nfunction formatArgs() {\n  var args = arguments;\n  var useColors = this.useColors;\n\n  args[0] = (useColors ? '%c' : '')\n    + this.namespace\n    + (useColors ? ' %c' : ' ')\n    + args[0]\n    + (useColors ? '%c ' : ' ')\n    + '+' + exports.humanize(this.diff);\n\n  if (!useColors) return args;\n\n  var c = 'color: ' + this.color;\n  args = [args[0], c, 'color: inherit'].concat(Array.prototype.slice.call(args, 1));\n\n  // the final \"%c\" is somewhat tricky, because there could be other\n  // arguments passed either before or after the %c, so we need to\n  // figure out the correct index to insert the CSS into\n  var index = 0;\n  var lastC = 0;\n  args[0].replace(/%[a-z%]/g, function(match) {\n    if ('%%' === match) return;\n    index++;\n    if ('%c' === match) {\n      // we only are interested in the *last* %c\n      // (the user may have provided their own)\n      lastC = index;\n    }\n  });\n\n  args.splice(lastC, 0, c);\n  return args;\n}\n\n/**\n * Invokes `console.log()` when available.\n * No-op when `console.log` is not a \"function\".\n *\n * @api public\n */\n\nfunction log() {\n  // this hackery is required for IE8/9, where\n  // the `console.log` function doesn't have 'apply'\n  return 'object' === typeof console\n    && console.log\n    && Function.prototype.apply.call(console.log, console, arguments);\n}\n\n/**\n * Save `namespaces`.\n *\n * @param {String} namespaces\n * @api private\n */\n\nfunction save(namespaces) {\n  try {\n    if (null == namespaces) {\n      exports.storage.removeItem('debug');\n    } else {\n      exports.storage.debug = namespaces;\n    }\n  } catch(e) {}\n}\n\n/**\n * Load `namespaces`.\n *\n * @return {String} returns the previously persisted debug modes\n * @api private\n */\n\nfunction load() {\n  var r;\n  try {\n    r = exports.storage.debug;\n  } catch(e) {}\n  return r;\n}\n\n/**\n * Enable namespaces listed in `localStorage.debug` initially.\n */\n\nexports.enable(load());\n\n/**\n * Localstorage attempts to return the localstorage.\n *\n * This is necessary because safari throws\n * when a user disables cookies/localstorage\n * and you attempt to access it.\n *\n * @return {LocalStorage}\n * @api private\n */\n\nfunction localstorage(){\n  try {\n    return window.localStorage;\n  } catch (e) {}\n}\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ../~/socket.io-parser/~/debug/browser.js\n// module id = 453\n// module chunks = 1 4 8 9 11","\n/**\n * This is the common logic for both the Node.js and web browser\n * implementations of `debug()`.\n *\n * Expose `debug()` as the module.\n */\n\nexports = module.exports = debug;\nexports.coerce = coerce;\nexports.disable = disable;\nexports.enable = enable;\nexports.enabled = enabled;\nexports.humanize = require('ms');\n\n/**\n * The currently active debug mode names, and names to skip.\n */\n\nexports.names = [];\nexports.skips = [];\n\n/**\n * Map of special \"%n\" handling functions, for the debug \"format\" argument.\n *\n * Valid key names are a single, lowercased letter, i.e. \"n\".\n */\n\nexports.formatters = {};\n\n/**\n * Previously assigned color.\n */\n\nvar prevColor = 0;\n\n/**\n * Previous log timestamp.\n */\n\nvar prevTime;\n\n/**\n * Select a color.\n *\n * @return {Number}\n * @api private\n */\n\nfunction selectColor() {\n  return exports.colors[prevColor++ % exports.colors.length];\n}\n\n/**\n * Create a debugger with the given `namespace`.\n *\n * @param {String} namespace\n * @return {Function}\n * @api public\n */\n\nfunction debug(namespace) {\n\n  // define the `disabled` version\n  function disabled() {\n  }\n  disabled.enabled = false;\n\n  // define the `enabled` version\n  function enabled() {\n\n    var self = enabled;\n\n    // set `diff` timestamp\n    var curr = +new Date();\n    var ms = curr - (prevTime || curr);\n    self.diff = ms;\n    self.prev = prevTime;\n    self.curr = curr;\n    prevTime = curr;\n\n    // add the `color` if not set\n    if (null == self.useColors) self.useColors = exports.useColors();\n    if (null == self.color && self.useColors) self.color = selectColor();\n\n    var args = Array.prototype.slice.call(arguments);\n\n    args[0] = exports.coerce(args[0]);\n\n    if ('string' !== typeof args[0]) {\n      // anything else let's inspect with %o\n      args = ['%o'].concat(args);\n    }\n\n    // apply any `formatters` transformations\n    var index = 0;\n    args[0] = args[0].replace(/%([a-z%])/g, function(match, format) {\n      // if we encounter an escaped % then don't increase the array index\n      if (match === '%%') return match;\n      index++;\n      var formatter = exports.formatters[format];\n      if ('function' === typeof formatter) {\n        var val = args[index];\n        match = formatter.call(self, val);\n\n        // now we need to remove `args[index]` since it's inlined in the `format`\n        args.splice(index, 1);\n        index--;\n      }\n      return match;\n    });\n\n    if ('function' === typeof exports.formatArgs) {\n      args = exports.formatArgs.apply(self, args);\n    }\n    var logFn = enabled.log || exports.log || console.log.bind(console);\n    logFn.apply(self, args);\n  }\n  enabled.enabled = true;\n\n  var fn = exports.enabled(namespace) ? enabled : disabled;\n\n  fn.namespace = namespace;\n\n  return fn;\n}\n\n/**\n * Enables a debug mode by namespaces. This can include modes\n * separated by a colon and wildcards.\n *\n * @param {String} namespaces\n * @api public\n */\n\nfunction enable(namespaces) {\n  exports.save(namespaces);\n\n  var split = (namespaces || '').split(/[\\s,]+/);\n  var len = split.length;\n\n  for (var i = 0; i < len; i++) {\n    if (!split[i]) continue; // ignore empty strings\n    namespaces = split[i].replace(/\\*/g, '.*?');\n    if (namespaces[0] === '-') {\n      exports.skips.push(new RegExp('^' + namespaces.substr(1) + '$'));\n    } else {\n      exports.names.push(new RegExp('^' + namespaces + '$'));\n    }\n  }\n}\n\n/**\n * Disable debug output.\n *\n * @api public\n */\n\nfunction disable() {\n  exports.enable('');\n}\n\n/**\n * Returns true if the given mode name is enabled, false otherwise.\n *\n * @param {String} name\n * @return {Boolean}\n * @api public\n */\n\nfunction enabled(name) {\n  var i, len;\n  for (i = 0, len = exports.skips.length; i < len; i++) {\n    if (exports.skips[i].test(name)) {\n      return false;\n    }\n  }\n  for (i = 0, len = exports.names.length; i < len; i++) {\n    if (exports.names[i].test(name)) {\n      return true;\n    }\n  }\n  return false;\n}\n\n/**\n * Coerce `val`.\n *\n * @param {Mixed} val\n * @return {Mixed}\n * @api private\n */\n\nfunction coerce(val) {\n  if (val instanceof Error) return val.stack || val.message;\n  return val;\n}\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ../~/socket.io-parser/~/debug/debug.js\n// module id = 454\n// module chunks = 1 4 8 9 11","/**\n * Helpers.\n */\n\nvar s = 1000;\nvar m = s * 60;\nvar h = m * 60;\nvar d = h * 24;\nvar y = d * 365.25;\n\n/**\n * Parse or format the given `val`.\n *\n * Options:\n *\n *  - `long` verbose formatting [false]\n *\n * @param {String|Number} val\n * @param {Object} options\n * @return {String|Number}\n * @api public\n */\n\nmodule.exports = function(val, options){\n  options = options || {};\n  if ('string' == typeof val) return parse(val);\n  return options.long\n    ? long(val)\n    : short(val);\n};\n\n/**\n * Parse the given `str` and return milliseconds.\n *\n * @param {String} str\n * @return {Number}\n * @api private\n */\n\nfunction parse(str) {\n  str = '' + str;\n  if (str.length > 10000) return;\n  var match = /^((?:\\d+)?\\.?\\d+) *(milliseconds?|msecs?|ms|seconds?|secs?|s|minutes?|mins?|m|hours?|hrs?|h|days?|d|years?|yrs?|y)?$/i.exec(str);\n  if (!match) return;\n  var n = parseFloat(match[1]);\n  var type = (match[2] || 'ms').toLowerCase();\n  switch (type) {\n    case 'years':\n    case 'year':\n    case 'yrs':\n    case 'yr':\n    case 'y':\n      return n * y;\n    case 'days':\n    case 'day':\n    case 'd':\n      return n * d;\n    case 'hours':\n    case 'hour':\n    case 'hrs':\n    case 'hr':\n    case 'h':\n      return n * h;\n    case 'minutes':\n    case 'minute':\n    case 'mins':\n    case 'min':\n    case 'm':\n      return n * m;\n    case 'seconds':\n    case 'second':\n    case 'secs':\n    case 'sec':\n    case 's':\n      return n * s;\n    case 'milliseconds':\n    case 'millisecond':\n    case 'msecs':\n    case 'msec':\n    case 'ms':\n      return n;\n  }\n}\n\n/**\n * Short format for `ms`.\n *\n * @param {Number} ms\n * @return {String}\n * @api private\n */\n\nfunction short(ms) {\n  if (ms >= d) return Math.round(ms / d) + 'd';\n  if (ms >= h) return Math.round(ms / h) + 'h';\n  if (ms >= m) return Math.round(ms / m) + 'm';\n  if (ms >= s) return Math.round(ms / s) + 's';\n  return ms + 'ms';\n}\n\n/**\n * Long format for `ms`.\n *\n * @param {Number} ms\n * @return {String}\n * @api private\n */\n\nfunction long(ms) {\n  return plural(ms, d, 'day')\n    || plural(ms, h, 'hour')\n    || plural(ms, m, 'minute')\n    || plural(ms, s, 'second')\n    || ms + ' ms';\n}\n\n/**\n * Pluralization helper.\n */\n\nfunction plural(ms, n, name) {\n  if (ms < n) return;\n  if (ms < n * 1.5) return Math.floor(ms / n) + ' ' + name;\n  return Math.ceil(ms / n) + ' ' + name + 's';\n}\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ../~/socket.io-parser/~/ms/index.js\n// module id = 455\n// module chunks = 1 4 8 9 11","/*! JSON v3.3.2 | http://bestiejs.github.io/json3 | Copyright 2012-2014, Kit Cambridge | http://kit.mit-license.org */\n;(function () {\n  // Detect the `define` function exposed by asynchronous module loaders. The\n  // strict `define` check is necessary for compatibility with `r.js`.\n  var isLoader = typeof define === \"function\" && define.amd;\n\n  // A set of types used to distinguish objects from primitives.\n  var objectTypes = {\n    \"function\": true,\n    \"object\": true\n  };\n\n  // Detect the `exports` object exposed by CommonJS implementations.\n  var freeExports = objectTypes[typeof exports] && exports && !exports.nodeType && exports;\n\n  // Use the `global` object exposed by Node (including Browserify via\n  // `insert-module-globals`), Narwhal, and Ringo as the default context,\n  // and the `window` object in browsers. Rhino exports a `global` function\n  // instead.\n  var root = objectTypes[typeof window] && window || this,\n      freeGlobal = freeExports && objectTypes[typeof module] && module && !module.nodeType && typeof global == \"object\" && global;\n\n  if (freeGlobal && (freeGlobal[\"global\"] === freeGlobal || freeGlobal[\"window\"] === freeGlobal || freeGlobal[\"self\"] === freeGlobal)) {\n    root = freeGlobal;\n  }\n\n  // Public: Initializes JSON 3 using the given `context` object, attaching the\n  // `stringify` and `parse` functions to the specified `exports` object.\n  function runInContext(context, exports) {\n    context || (context = root[\"Object\"]());\n    exports || (exports = root[\"Object\"]());\n\n    // Native constructor aliases.\n    var Number = context[\"Number\"] || root[\"Number\"],\n        String = context[\"String\"] || root[\"String\"],\n        Object = context[\"Object\"] || root[\"Object\"],\n        Date = context[\"Date\"] || root[\"Date\"],\n        SyntaxError = context[\"SyntaxError\"] || root[\"SyntaxError\"],\n        TypeError = context[\"TypeError\"] || root[\"TypeError\"],\n        Math = context[\"Math\"] || root[\"Math\"],\n        nativeJSON = context[\"JSON\"] || root[\"JSON\"];\n\n    // Delegate to the native `stringify` and `parse` implementations.\n    if (typeof nativeJSON == \"object\" && nativeJSON) {\n      exports.stringify = nativeJSON.stringify;\n      exports.parse = nativeJSON.parse;\n    }\n\n    // Convenience aliases.\n    var objectProto = Object.prototype,\n        getClass = objectProto.toString,\n        isProperty, forEach, undef;\n\n    // Test the `Date#getUTC*` methods. Based on work by @Yaffle.\n    var isExtended = new Date(-3509827334573292);\n    try {\n      // The `getUTCFullYear`, `Month`, and `Date` methods return nonsensical\n      // results for certain dates in Opera >= 10.53.\n      isExtended = isExtended.getUTCFullYear() == -109252 && isExtended.getUTCMonth() === 0 && isExtended.getUTCDate() === 1 &&\n        // Safari < 2.0.2 stores the internal millisecond time value correctly,\n        // but clips the values returned by the date methods to the range of\n        // signed 32-bit integers ([-2 ** 31, 2 ** 31 - 1]).\n        isExtended.getUTCHours() == 10 && isExtended.getUTCMinutes() == 37 && isExtended.getUTCSeconds() == 6 && isExtended.getUTCMilliseconds() == 708;\n    } catch (exception) {}\n\n    // Internal: Determines whether the native `JSON.stringify` and `parse`\n    // implementations are spec-compliant. Based on work by Ken Snyder.\n    function has(name) {\n      if (has[name] !== undef) {\n        // Return cached feature test result.\n        return has[name];\n      }\n      var isSupported;\n      if (name == \"bug-string-char-index\") {\n        // IE <= 7 doesn't support accessing string characters using square\n        // bracket notation. IE 8 only supports this for primitives.\n        isSupported = \"a\"[0] != \"a\";\n      } else if (name == \"json\") {\n        // Indicates whether both `JSON.stringify` and `JSON.parse` are\n        // supported.\n        isSupported = has(\"json-stringify\") && has(\"json-parse\");\n      } else {\n        var value, serialized = '{\"a\":[1,true,false,null,\"\\\\u0000\\\\b\\\\n\\\\f\\\\r\\\\t\"]}';\n        // Test `JSON.stringify`.\n        if (name == \"json-stringify\") {\n          var stringify = exports.stringify, stringifySupported = typeof stringify == \"function\" && isExtended;\n          if (stringifySupported) {\n            // A test function object with a custom `toJSON` method.\n            (value = function () {\n              return 1;\n            }).toJSON = value;\n            try {\n              stringifySupported =\n                // Firefox 3.1b1 and b2 serialize string, number, and boolean\n                // primitives as object literals.\n                stringify(0) === \"0\" &&\n                // FF 3.1b1, b2, and JSON 2 serialize wrapped primitives as object\n                // literals.\n                stringify(new Number()) === \"0\" &&\n                stringify(new String()) == '\"\"' &&\n                // FF 3.1b1, 2 throw an error if the value is `null`, `undefined`, or\n                // does not define a canonical JSON representation (this applies to\n                // objects with `toJSON` properties as well, *unless* they are nested\n                // within an object or array).\n                stringify(getClass) === undef &&\n                // IE 8 serializes `undefined` as `\"undefined\"`. Safari <= 5.1.7 and\n                // FF 3.1b3 pass this test.\n                stringify(undef) === undef &&\n                // Safari <= 5.1.7 and FF 3.1b3 throw `Error`s and `TypeError`s,\n                // respectively, if the value is omitted entirely.\n                stringify() === undef &&\n                // FF 3.1b1, 2 throw an error if the given value is not a number,\n                // string, array, object, Boolean, or `null` literal. This applies to\n                // objects with custom `toJSON` methods as well, unless they are nested\n                // inside object or array literals. YUI 3.0.0b1 ignores custom `toJSON`\n                // methods entirely.\n                stringify(value) === \"1\" &&\n                stringify([value]) == \"[1]\" &&\n                // Prototype <= 1.6.1 serializes `[undefined]` as `\"[]\"` instead of\n                // `\"[null]\"`.\n                stringify([undef]) == \"[null]\" &&\n                // YUI 3.0.0b1 fails to serialize `null` literals.\n                stringify(null) == \"null\" &&\n                // FF 3.1b1, 2 halts serialization if an array contains a function:\n                // `[1, true, getClass, 1]` serializes as \"[1,true,],\". FF 3.1b3\n                // elides non-JSON values from objects and arrays, unless they\n                // define custom `toJSON` methods.\n                stringify([undef, getClass, null]) == \"[null,null,null]\" &&\n                // Simple serialization test. FF 3.1b1 uses Unicode escape sequences\n                // where character escape codes are expected (e.g., `\\b` => `\\u0008`).\n                stringify({ \"a\": [value, true, false, null, \"\\x00\\b\\n\\f\\r\\t\"] }) == serialized &&\n                // FF 3.1b1 and b2 ignore the `filter` and `width` arguments.\n                stringify(null, value) === \"1\" &&\n                stringify([1, 2], null, 1) == \"[\\n 1,\\n 2\\n]\" &&\n                // JSON 2, Prototype <= 1.7, and older WebKit builds incorrectly\n                // serialize extended years.\n                stringify(new Date(-8.64e15)) == '\"-271821-04-20T00:00:00.000Z\"' &&\n                // The milliseconds are optional in ES 5, but required in 5.1.\n                stringify(new Date(8.64e15)) == '\"+275760-09-13T00:00:00.000Z\"' &&\n                // Firefox <= 11.0 incorrectly serializes years prior to 0 as negative\n                // four-digit years instead of six-digit years. Credits: @Yaffle.\n                stringify(new Date(-621987552e5)) == '\"-000001-01-01T00:00:00.000Z\"' &&\n                // Safari <= 5.1.5 and Opera >= 10.53 incorrectly serialize millisecond\n                // values less than 1000. Credits: @Yaffle.\n                stringify(new Date(-1)) == '\"1969-12-31T23:59:59.999Z\"';\n            } catch (exception) {\n              stringifySupported = false;\n            }\n          }\n          isSupported = stringifySupported;\n        }\n        // Test `JSON.parse`.\n        if (name == \"json-parse\") {\n          var parse = exports.parse;\n          if (typeof parse == \"function\") {\n            try {\n              // FF 3.1b1, b2 will throw an exception if a bare literal is provided.\n              // Conforming implementations should also coerce the initial argument to\n              // a string prior to parsing.\n              if (parse(\"0\") === 0 && !parse(false)) {\n                // Simple parsing test.\n                value = parse(serialized);\n                var parseSupported = value[\"a\"].length == 5 && value[\"a\"][0] === 1;\n                if (parseSupported) {\n                  try {\n                    // Safari <= 5.1.2 and FF 3.1b1 allow unescaped tabs in strings.\n                    parseSupported = !parse('\"\\t\"');\n                  } catch (exception) {}\n                  if (parseSupported) {\n                    try {\n                      // FF 4.0 and 4.0.1 allow leading `+` signs and leading\n                      // decimal points. FF 4.0, 4.0.1, and IE 9-10 also allow\n                      // certain octal literals.\n                      parseSupported = parse(\"01\") !== 1;\n                    } catch (exception) {}\n                  }\n                  if (parseSupported) {\n                    try {\n                      // FF 4.0, 4.0.1, and Rhino 1.7R3-R4 allow trailing decimal\n                      // points. These environments, along with FF 3.1b1 and 2,\n                      // also allow trailing commas in JSON objects and arrays.\n                      parseSupported = parse(\"1.\") !== 1;\n                    } catch (exception) {}\n                  }\n                }\n              }\n            } catch (exception) {\n              parseSupported = false;\n            }\n          }\n          isSupported = parseSupported;\n        }\n      }\n      return has[name] = !!isSupported;\n    }\n\n    if (!has(\"json\")) {\n      // Common `[[Class]]` name aliases.\n      var functionClass = \"[object Function]\",\n          dateClass = \"[object Date]\",\n          numberClass = \"[object Number]\",\n          stringClass = \"[object String]\",\n          arrayClass = \"[object Array]\",\n          booleanClass = \"[object Boolean]\";\n\n      // Detect incomplete support for accessing string characters by index.\n      var charIndexBuggy = has(\"bug-string-char-index\");\n\n      // Define additional utility methods if the `Date` methods are buggy.\n      if (!isExtended) {\n        var floor = Math.floor;\n        // A mapping between the months of the year and the number of days between\n        // January 1st and the first of the respective month.\n        var Months = [0, 31, 59, 90, 120, 151, 181, 212, 243, 273, 304, 334];\n        // Internal: Calculates the number of days between the Unix epoch and the\n        // first day of the given month.\n        var getDay = function (year, month) {\n          return Months[month] + 365 * (year - 1970) + floor((year - 1969 + (month = +(month > 1))) / 4) - floor((year - 1901 + month) / 100) + floor((year - 1601 + month) / 400);\n        };\n      }\n\n      // Internal: Determines if a property is a direct property of the given\n      // object. Delegates to the native `Object#hasOwnProperty` method.\n      if (!(isProperty = objectProto.hasOwnProperty)) {\n        isProperty = function (property) {\n          var members = {}, constructor;\n          if ((members.__proto__ = null, members.__proto__ = {\n            // The *proto* property cannot be set multiple times in recent\n            // versions of Firefox and SeaMonkey.\n            \"toString\": 1\n          }, members).toString != getClass) {\n            // Safari <= 2.0.3 doesn't implement `Object#hasOwnProperty`, but\n            // supports the mutable *proto* property.\n            isProperty = function (property) {\n              // Capture and break the object's prototype chain (see section 8.6.2\n              // of the ES 5.1 spec). The parenthesized expression prevents an\n              // unsafe transformation by the Closure Compiler.\n              var original = this.__proto__, result = property in (this.__proto__ = null, this);\n              // Restore the original prototype chain.\n              this.__proto__ = original;\n              return result;\n            };\n          } else {\n            // Capture a reference to the top-level `Object` constructor.\n            constructor = members.constructor;\n            // Use the `constructor` property to simulate `Object#hasOwnProperty` in\n            // other environments.\n            isProperty = function (property) {\n              var parent = (this.constructor || constructor).prototype;\n              return property in this && !(property in parent && this[property] === parent[property]);\n            };\n          }\n          members = null;\n          return isProperty.call(this, property);\n        };\n      }\n\n      // Internal: Normalizes the `for...in` iteration algorithm across\n      // environments. Each enumerated key is yielded to a `callback` function.\n      forEach = function (object, callback) {\n        var size = 0, Properties, members, property;\n\n        // Tests for bugs in the current environment's `for...in` algorithm. The\n        // `valueOf` property inherits the non-enumerable flag from\n        // `Object.prototype` in older versions of IE, Netscape, and Mozilla.\n        (Properties = function () {\n          this.valueOf = 0;\n        }).prototype.valueOf = 0;\n\n        // Iterate over a new instance of the `Properties` class.\n        members = new Properties();\n        for (property in members) {\n          // Ignore all properties inherited from `Object.prototype`.\n          if (isProperty.call(members, property)) {\n            size++;\n          }\n        }\n        Properties = members = null;\n\n        // Normalize the iteration algorithm.\n        if (!size) {\n          // A list of non-enumerable properties inherited from `Object.prototype`.\n          members = [\"valueOf\", \"toString\", \"toLocaleString\", \"propertyIsEnumerable\", \"isPrototypeOf\", \"hasOwnProperty\", \"constructor\"];\n          // IE <= 8, Mozilla 1.0, and Netscape 6.2 ignore shadowed non-enumerable\n          // properties.\n          forEach = function (object, callback) {\n            var isFunction = getClass.call(object) == functionClass, property, length;\n            var hasProperty = !isFunction && typeof object.constructor != \"function\" && objectTypes[typeof object.hasOwnProperty] && object.hasOwnProperty || isProperty;\n            for (property in object) {\n              // Gecko <= 1.0 enumerates the `prototype` property of functions under\n              // certain conditions; IE does not.\n              if (!(isFunction && property == \"prototype\") && hasProperty.call(object, property)) {\n                callback(property);\n              }\n            }\n            // Manually invoke the callback for each non-enumerable property.\n            for (length = members.length; property = members[--length]; hasProperty.call(object, property) && callback(property));\n          };\n        } else if (size == 2) {\n          // Safari <= 2.0.4 enumerates shadowed properties twice.\n          forEach = function (object, callback) {\n            // Create a set of iterated properties.\n            var members = {}, isFunction = getClass.call(object) == functionClass, property;\n            for (property in object) {\n              // Store each property name to prevent double enumeration. The\n              // `prototype` property of functions is not enumerated due to cross-\n              // environment inconsistencies.\n              if (!(isFunction && property == \"prototype\") && !isProperty.call(members, property) && (members[property] = 1) && isProperty.call(object, property)) {\n                callback(property);\n              }\n            }\n          };\n        } else {\n          // No bugs detected; use the standard `for...in` algorithm.\n          forEach = function (object, callback) {\n            var isFunction = getClass.call(object) == functionClass, property, isConstructor;\n            for (property in object) {\n              if (!(isFunction && property == \"prototype\") && isProperty.call(object, property) && !(isConstructor = property === \"constructor\")) {\n                callback(property);\n              }\n            }\n            // Manually invoke the callback for the `constructor` property due to\n            // cross-environment inconsistencies.\n            if (isConstructor || isProperty.call(object, (property = \"constructor\"))) {\n              callback(property);\n            }\n          };\n        }\n        return forEach(object, callback);\n      };\n\n      // Public: Serializes a JavaScript `value` as a JSON string. The optional\n      // `filter` argument may specify either a function that alters how object and\n      // array members are serialized, or an array of strings and numbers that\n      // indicates which properties should be serialized. The optional `width`\n      // argument may be either a string or number that specifies the indentation\n      // level of the output.\n      if (!has(\"json-stringify\")) {\n        // Internal: A map of control characters and their escaped equivalents.\n        var Escapes = {\n          92: \"\\\\\\\\\",\n          34: '\\\\\"',\n          8: \"\\\\b\",\n          12: \"\\\\f\",\n          10: \"\\\\n\",\n          13: \"\\\\r\",\n          9: \"\\\\t\"\n        };\n\n        // Internal: Converts `value` into a zero-padded string such that its\n        // length is at least equal to `width`. The `width` must be <= 6.\n        var leadingZeroes = \"000000\";\n        var toPaddedString = function (width, value) {\n          // The `|| 0` expression is necessary to work around a bug in\n          // Opera <= 7.54u2 where `0 == -0`, but `String(-0) !== \"0\"`.\n          return (leadingZeroes + (value || 0)).slice(-width);\n        };\n\n        // Internal: Double-quotes a string `value`, replacing all ASCII control\n        // characters (characters with code unit values between 0 and 31) with\n        // their escaped equivalents. This is an implementation of the\n        // `Quote(value)` operation defined in ES 5.1 section 15.12.3.\n        var unicodePrefix = \"\\\\u00\";\n        var quote = function (value) {\n          var result = '\"', index = 0, length = value.length, useCharIndex = !charIndexBuggy || length > 10;\n          var symbols = useCharIndex && (charIndexBuggy ? value.split(\"\") : value);\n          for (; index < length; index++) {\n            var charCode = value.charCodeAt(index);\n            // If the character is a control character, append its Unicode or\n            // shorthand escape sequence; otherwise, append the character as-is.\n            switch (charCode) {\n              case 8: case 9: case 10: case 12: case 13: case 34: case 92:\n                result += Escapes[charCode];\n                break;\n              default:\n                if (charCode < 32) {\n                  result += unicodePrefix + toPaddedString(2, charCode.toString(16));\n                  break;\n                }\n                result += useCharIndex ? symbols[index] : value.charAt(index);\n            }\n          }\n          return result + '\"';\n        };\n\n        // Internal: Recursively serializes an object. Implements the\n        // `Str(key, holder)`, `JO(value)`, and `JA(value)` operations.\n        var serialize = function (property, object, callback, properties, whitespace, indentation, stack) {\n          var value, className, year, month, date, time, hours, minutes, seconds, milliseconds, results, element, index, length, prefix, result;\n          try {\n            // Necessary for host object support.\n            value = object[property];\n          } catch (exception) {}\n          if (typeof value == \"object\" && value) {\n            className = getClass.call(value);\n            if (className == dateClass && !isProperty.call(value, \"toJSON\")) {\n              if (value > -1 / 0 && value < 1 / 0) {\n                // Dates are serialized according to the `Date#toJSON` method\n                // specified in ES 5.1 section 15.9.5.44. See section 15.9.1.15\n                // for the ISO 8601 date time string format.\n                if (getDay) {\n                  // Manually compute the year, month, date, hours, minutes,\n                  // seconds, and milliseconds if the `getUTC*` methods are\n                  // buggy. Adapted from @Yaffle's `date-shim` project.\n                  date = floor(value / 864e5);\n                  for (year = floor(date / 365.2425) + 1970 - 1; getDay(year + 1, 0) <= date; year++);\n                  for (month = floor((date - getDay(year, 0)) / 30.42); getDay(year, month + 1) <= date; month++);\n                  date = 1 + date - getDay(year, month);\n                  // The `time` value specifies the time within the day (see ES\n                  // 5.1 section 15.9.1.2). The formula `(A % B + B) % B` is used\n                  // to compute `A modulo B`, as the `%` operator does not\n                  // correspond to the `modulo` operation for negative numbers.\n                  time = (value % 864e5 + 864e5) % 864e5;\n                  // The hours, minutes, seconds, and milliseconds are obtained by\n                  // decomposing the time within the day. See section 15.9.1.10.\n                  hours = floor(time / 36e5) % 24;\n                  minutes = floor(time / 6e4) % 60;\n                  seconds = floor(time / 1e3) % 60;\n                  milliseconds = time % 1e3;\n                } else {\n                  year = value.getUTCFullYear();\n                  month = value.getUTCMonth();\n                  date = value.getUTCDate();\n                  hours = value.getUTCHours();\n                  minutes = value.getUTCMinutes();\n                  seconds = value.getUTCSeconds();\n                  milliseconds = value.getUTCMilliseconds();\n                }\n                // Serialize extended years correctly.\n                value = (year <= 0 || year >= 1e4 ? (year < 0 ? \"-\" : \"+\") + toPaddedString(6, year < 0 ? -year : year) : toPaddedString(4, year)) +\n                  \"-\" + toPaddedString(2, month + 1) + \"-\" + toPaddedString(2, date) +\n                  // Months, dates, hours, minutes, and seconds should have two\n                  // digits; milliseconds should have three.\n                  \"T\" + toPaddedString(2, hours) + \":\" + toPaddedString(2, minutes) + \":\" + toPaddedString(2, seconds) +\n                  // Milliseconds are optional in ES 5.0, but required in 5.1.\n                  \".\" + toPaddedString(3, milliseconds) + \"Z\";\n              } else {\n                value = null;\n              }\n            } else if (typeof value.toJSON == \"function\" && ((className != numberClass && className != stringClass && className != arrayClass) || isProperty.call(value, \"toJSON\"))) {\n              // Prototype <= 1.6.1 adds non-standard `toJSON` methods to the\n              // `Number`, `String`, `Date`, and `Array` prototypes. JSON 3\n              // ignores all `toJSON` methods on these objects unless they are\n              // defined directly on an instance.\n              value = value.toJSON(property);\n            }\n          }\n          if (callback) {\n            // If a replacement function was provided, call it to obtain the value\n            // for serialization.\n            value = callback.call(object, property, value);\n          }\n          if (value === null) {\n            return \"null\";\n          }\n          className = getClass.call(value);\n          if (className == booleanClass) {\n            // Booleans are represented literally.\n            return \"\" + value;\n          } else if (className == numberClass) {\n            // JSON numbers must be finite. `Infinity` and `NaN` are serialized as\n            // `\"null\"`.\n            return value > -1 / 0 && value < 1 / 0 ? \"\" + value : \"null\";\n          } else if (className == stringClass) {\n            // Strings are double-quoted and escaped.\n            return quote(\"\" + value);\n          }\n          // Recursively serialize objects and arrays.\n          if (typeof value == \"object\") {\n            // Check for cyclic structures. This is a linear search; performance\n            // is inversely proportional to the number of unique nested objects.\n            for (length = stack.length; length--;) {\n              if (stack[length] === value) {\n                // Cyclic structures cannot be serialized by `JSON.stringify`.\n                throw TypeError();\n              }\n            }\n            // Add the object to the stack of traversed objects.\n            stack.push(value);\n            results = [];\n            // Save the current indentation level and indent one additional level.\n            prefix = indentation;\n            indentation += whitespace;\n            if (className == arrayClass) {\n              // Recursively serialize array elements.\n              for (index = 0, length = value.length; index < length; index++) {\n                element = serialize(index, value, callback, properties, whitespace, indentation, stack);\n                results.push(element === undef ? \"null\" : element);\n              }\n              result = results.length ? (whitespace ? \"[\\n\" + indentation + results.join(\",\\n\" + indentation) + \"\\n\" + prefix + \"]\" : (\"[\" + results.join(\",\") + \"]\")) : \"[]\";\n            } else {\n              // Recursively serialize object members. Members are selected from\n              // either a user-specified list of property names, or the object\n              // itself.\n              forEach(properties || value, function (property) {\n                var element = serialize(property, value, callback, properties, whitespace, indentation, stack);\n                if (element !== undef) {\n                  // According to ES 5.1 section 15.12.3: \"If `gap` {whitespace}\n                  // is not the empty string, let `member` {quote(property) + \":\"}\n                  // be the concatenation of `member` and the `space` character.\"\n                  // The \"`space` character\" refers to the literal space\n                  // character, not the `space` {width} argument provided to\n                  // `JSON.stringify`.\n                  results.push(quote(property) + \":\" + (whitespace ? \" \" : \"\") + element);\n                }\n              });\n              result = results.length ? (whitespace ? \"{\\n\" + indentation + results.join(\",\\n\" + indentation) + \"\\n\" + prefix + \"}\" : (\"{\" + results.join(\",\") + \"}\")) : \"{}\";\n            }\n            // Remove the object from the traversed object stack.\n            stack.pop();\n            return result;\n          }\n        };\n\n        // Public: `JSON.stringify`. See ES 5.1 section 15.12.3.\n        exports.stringify = function (source, filter, width) {\n          var whitespace, callback, properties, className;\n          if (objectTypes[typeof filter] && filter) {\n            if ((className = getClass.call(filter)) == functionClass) {\n              callback = filter;\n            } else if (className == arrayClass) {\n              // Convert the property names array into a makeshift set.\n              properties = {};\n              for (var index = 0, length = filter.length, value; index < length; value = filter[index++], ((className = getClass.call(value)), className == stringClass || className == numberClass) && (properties[value] = 1));\n            }\n          }\n          if (width) {\n            if ((className = getClass.call(width)) == numberClass) {\n              // Convert the `width` to an integer and create a string containing\n              // `width` number of space characters.\n              if ((width -= width % 1) > 0) {\n                for (whitespace = \"\", width > 10 && (width = 10); whitespace.length < width; whitespace += \" \");\n              }\n            } else if (className == stringClass) {\n              whitespace = width.length <= 10 ? width : width.slice(0, 10);\n            }\n          }\n          // Opera <= 7.54u2 discards the values associated with empty string keys\n          // (`\"\"`) only if they are used directly within an object member list\n          // (e.g., `!(\"\" in { \"\": 1})`).\n          return serialize(\"\", (value = {}, value[\"\"] = source, value), callback, properties, whitespace, \"\", []);\n        };\n      }\n\n      // Public: Parses a JSON source string.\n      if (!has(\"json-parse\")) {\n        var fromCharCode = String.fromCharCode;\n\n        // Internal: A map of escaped control characters and their unescaped\n        // equivalents.\n        var Unescapes = {\n          92: \"\\\\\",\n          34: '\"',\n          47: \"/\",\n          98: \"\\b\",\n          116: \"\\t\",\n          110: \"\\n\",\n          102: \"\\f\",\n          114: \"\\r\"\n        };\n\n        // Internal: Stores the parser state.\n        var Index, Source;\n\n        // Internal: Resets the parser state and throws a `SyntaxError`.\n        var abort = function () {\n          Index = Source = null;\n          throw SyntaxError();\n        };\n\n        // Internal: Returns the next token, or `\"$\"` if the parser has reached\n        // the end of the source string. A token may be a string, number, `null`\n        // literal, or Boolean literal.\n        var lex = function () {\n          var source = Source, length = source.length, value, begin, position, isSigned, charCode;\n          while (Index < length) {\n            charCode = source.charCodeAt(Index);\n            switch (charCode) {\n              case 9: case 10: case 13: case 32:\n                // Skip whitespace tokens, including tabs, carriage returns, line\n                // feeds, and space characters.\n                Index++;\n                break;\n              case 123: case 125: case 91: case 93: case 58: case 44:\n                // Parse a punctuator token (`{`, `}`, `[`, `]`, `:`, or `,`) at\n                // the current position.\n                value = charIndexBuggy ? source.charAt(Index) : source[Index];\n                Index++;\n                return value;\n              case 34:\n                // `\"` delimits a JSON string; advance to the next character and\n                // begin parsing the string. String tokens are prefixed with the\n                // sentinel `@` character to distinguish them from punctuators and\n                // end-of-string tokens.\n                for (value = \"@\", Index++; Index < length;) {\n                  charCode = source.charCodeAt(Index);\n                  if (charCode < 32) {\n                    // Unescaped ASCII control characters (those with a code unit\n                    // less than the space character) are not permitted.\n                    abort();\n                  } else if (charCode == 92) {\n                    // A reverse solidus (`\\`) marks the beginning of an escaped\n                    // control character (including `\"`, `\\`, and `/`) or Unicode\n                    // escape sequence.\n                    charCode = source.charCodeAt(++Index);\n                    switch (charCode) {\n                      case 92: case 34: case 47: case 98: case 116: case 110: case 102: case 114:\n                        // Revive escaped control characters.\n                        value += Unescapes[charCode];\n                        Index++;\n                        break;\n                      case 117:\n                        // `\\u` marks the beginning of a Unicode escape sequence.\n                        // Advance to the first character and validate the\n                        // four-digit code point.\n                        begin = ++Index;\n                        for (position = Index + 4; Index < position; Index++) {\n                          charCode = source.charCodeAt(Index);\n                          // A valid sequence comprises four hexdigits (case-\n                          // insensitive) that form a single hexadecimal value.\n                          if (!(charCode >= 48 && charCode <= 57 || charCode >= 97 && charCode <= 102 || charCode >= 65 && charCode <= 70)) {\n                            // Invalid Unicode escape sequence.\n                            abort();\n                          }\n                        }\n                        // Revive the escaped character.\n                        value += fromCharCode(\"0x\" + source.slice(begin, Index));\n                        break;\n                      default:\n                        // Invalid escape sequence.\n                        abort();\n                    }\n                  } else {\n                    if (charCode == 34) {\n                      // An unescaped double-quote character marks the end of the\n                      // string.\n                      break;\n                    }\n                    charCode = source.charCodeAt(Index);\n                    begin = Index;\n                    // Optimize for the common case where a string is valid.\n                    while (charCode >= 32 && charCode != 92 && charCode != 34) {\n                      charCode = source.charCodeAt(++Index);\n                    }\n                    // Append the string as-is.\n                    value += source.slice(begin, Index);\n                  }\n                }\n                if (source.charCodeAt(Index) == 34) {\n                  // Advance to the next character and return the revived string.\n                  Index++;\n                  return value;\n                }\n                // Unterminated string.\n                abort();\n              default:\n                // Parse numbers and literals.\n                begin = Index;\n                // Advance past the negative sign, if one is specified.\n                if (charCode == 45) {\n                  isSigned = true;\n                  charCode = source.charCodeAt(++Index);\n                }\n                // Parse an integer or floating-point value.\n                if (charCode >= 48 && charCode <= 57) {\n                  // Leading zeroes are interpreted as octal literals.\n                  if (charCode == 48 && ((charCode = source.charCodeAt(Index + 1)), charCode >= 48 && charCode <= 57)) {\n                    // Illegal octal literal.\n                    abort();\n                  }\n                  isSigned = false;\n                  // Parse the integer component.\n                  for (; Index < length && ((charCode = source.charCodeAt(Index)), charCode >= 48 && charCode <= 57); Index++);\n                  // Floats cannot contain a leading decimal point; however, this\n                  // case is already accounted for by the parser.\n                  if (source.charCodeAt(Index) == 46) {\n                    position = ++Index;\n                    // Parse the decimal component.\n                    for (; position < length && ((charCode = source.charCodeAt(position)), charCode >= 48 && charCode <= 57); position++);\n                    if (position == Index) {\n                      // Illegal trailing decimal.\n                      abort();\n                    }\n                    Index = position;\n                  }\n                  // Parse exponents. The `e` denoting the exponent is\n                  // case-insensitive.\n                  charCode = source.charCodeAt(Index);\n                  if (charCode == 101 || charCode == 69) {\n                    charCode = source.charCodeAt(++Index);\n                    // Skip past the sign following the exponent, if one is\n                    // specified.\n                    if (charCode == 43 || charCode == 45) {\n                      Index++;\n                    }\n                    // Parse the exponential component.\n                    for (position = Index; position < length && ((charCode = source.charCodeAt(position)), charCode >= 48 && charCode <= 57); position++);\n                    if (position == Index) {\n                      // Illegal empty exponent.\n                      abort();\n                    }\n                    Index = position;\n                  }\n                  // Coerce the parsed value to a JavaScript number.\n                  return +source.slice(begin, Index);\n                }\n                // A negative sign may only precede numbers.\n                if (isSigned) {\n                  abort();\n                }\n                // `true`, `false`, and `null` literals.\n                if (source.slice(Index, Index + 4) == \"true\") {\n                  Index += 4;\n                  return true;\n                } else if (source.slice(Index, Index + 5) == \"false\") {\n                  Index += 5;\n                  return false;\n                } else if (source.slice(Index, Index + 4) == \"null\") {\n                  Index += 4;\n                  return null;\n                }\n                // Unrecognized token.\n                abort();\n            }\n          }\n          // Return the sentinel `$` character if the parser has reached the end\n          // of the source string.\n          return \"$\";\n        };\n\n        // Internal: Parses a JSON `value` token.\n        var get = function (value) {\n          var results, hasMembers;\n          if (value == \"$\") {\n            // Unexpected end of input.\n            abort();\n          }\n          if (typeof value == \"string\") {\n            if ((charIndexBuggy ? value.charAt(0) : value[0]) == \"@\") {\n              // Remove the sentinel `@` character.\n              return value.slice(1);\n            }\n            // Parse object and array literals.\n            if (value == \"[\") {\n              // Parses a JSON array, returning a new JavaScript array.\n              results = [];\n              for (;; hasMembers || (hasMembers = true)) {\n                value = lex();\n                // A closing square bracket marks the end of the array literal.\n                if (value == \"]\") {\n                  break;\n                }\n                // If the array literal contains elements, the current token\n                // should be a comma separating the previous element from the\n                // next.\n                if (hasMembers) {\n                  if (value == \",\") {\n                    value = lex();\n                    if (value == \"]\") {\n                      // Unexpected trailing `,` in array literal.\n                      abort();\n                    }\n                  } else {\n                    // A `,` must separate each array element.\n                    abort();\n                  }\n                }\n                // Elisions and leading commas are not permitted.\n                if (value == \",\") {\n                  abort();\n                }\n                results.push(get(value));\n              }\n              return results;\n            } else if (value == \"{\") {\n              // Parses a JSON object, returning a new JavaScript object.\n              results = {};\n              for (;; hasMembers || (hasMembers = true)) {\n                value = lex();\n                // A closing curly brace marks the end of the object literal.\n                if (value == \"}\") {\n                  break;\n                }\n                // If the object literal contains members, the current token\n                // should be a comma separator.\n                if (hasMembers) {\n                  if (value == \",\") {\n                    value = lex();\n                    if (value == \"}\") {\n                      // Unexpected trailing `,` in object literal.\n                      abort();\n                    }\n                  } else {\n                    // A `,` must separate each object member.\n                    abort();\n                  }\n                }\n                // Leading commas are not permitted, object property names must be\n                // double-quoted strings, and a `:` must separate each property\n                // name and value.\n                if (value == \",\" || typeof value != \"string\" || (charIndexBuggy ? value.charAt(0) : value[0]) != \"@\" || lex() != \":\") {\n                  abort();\n                }\n                results[value.slice(1)] = get(lex());\n              }\n              return results;\n            }\n            // Unexpected token encountered.\n            abort();\n          }\n          return value;\n        };\n\n        // Internal: Updates a traversed object member.\n        var update = function (source, property, callback) {\n          var element = walk(source, property, callback);\n          if (element === undef) {\n            delete source[property];\n          } else {\n            source[property] = element;\n          }\n        };\n\n        // Internal: Recursively traverses a parsed JSON object, invoking the\n        // `callback` function for each value. This is an implementation of the\n        // `Walk(holder, name)` operation defined in ES 5.1 section 15.12.2.\n        var walk = function (source, property, callback) {\n          var value = source[property], length;\n          if (typeof value == \"object\" && value) {\n            // `forEach` can't be used to traverse an array in Opera <= 8.54\n            // because its `Object#hasOwnProperty` implementation returns `false`\n            // for array indices (e.g., `![1, 2, 3].hasOwnProperty(\"0\")`).\n            if (getClass.call(value) == arrayClass) {\n              for (length = value.length; length--;) {\n                update(value, length, callback);\n              }\n            } else {\n              forEach(value, function (property) {\n                update(value, property, callback);\n              });\n            }\n          }\n          return callback.call(source, property, value);\n        };\n\n        // Public: `JSON.parse`. See ES 5.1 section 15.12.2.\n        exports.parse = function (source, callback) {\n          var result, value;\n          Index = 0;\n          Source = \"\" + source;\n          result = get(lex());\n          // If a JSON string contains multiple tokens, it is invalid.\n          if (lex() != \"$\") {\n            abort();\n          }\n          // Reset the parser state.\n          Index = Source = null;\n          return callback && getClass.call(callback) == functionClass ? walk((value = {}, value[\"\"] = result, value), \"\", callback) : result;\n        };\n      }\n    }\n\n    exports[\"runInContext\"] = runInContext;\n    return exports;\n  }\n\n  if (freeExports && !isLoader) {\n    // Export for CommonJS environments.\n    runInContext(root, freeExports);\n  } else {\n    // Export for web browsers and JavaScript engines.\n    var nativeJSON = root.JSON,\n        previousJSON = root[\"JSON3\"],\n        isRestored = false;\n\n    var JSON3 = runInContext(root, (root[\"JSON3\"] = {\n      // Public: Restores the original value of the global `JSON` object and\n      // returns a reference to the `JSON3` object.\n      \"noConflict\": function () {\n        if (!isRestored) {\n          isRestored = true;\n          root.JSON = nativeJSON;\n          root[\"JSON3\"] = previousJSON;\n          nativeJSON = previousJSON = null;\n        }\n        return JSON3;\n      }\n    }));\n\n    root.JSON = {\n      \"parse\": JSON3.parse,\n      \"stringify\": JSON3.stringify\n    };\n  }\n\n  // Export for asynchronous module loaders.\n  if (isLoader) {\n    define(function () {\n      return JSON3;\n    });\n  }\n}).call(this);\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ../~/json3/lib/json3.js\n// module id = 456\n// module chunks = 1 4 8 9 11","module.exports = function(module) {\r\n\tif(!module.webpackPolyfill) {\r\n\t\tmodule.deprecate = function() {};\r\n\t\tmodule.paths = [];\r\n\t\t// module.parent = undefined by default\r\n\t\tmodule.children = [];\r\n\t\tmodule.webpackPolyfill = 1;\r\n\t}\r\n\treturn module;\r\n}\r\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ../~/webpack/buildin/module.js\n// module id = 457\n// module chunks = 1 4 8 9 11","module.exports = __webpack_amd_options__;\r\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ../~/webpack/buildin/amd-options.js\n// module id = 458\n// module chunks = 1 4 8 9 11","\n/**\n * Expose `Emitter`.\n */\n\nmodule.exports = Emitter;\n\n/**\n * Initialize a new `Emitter`.\n *\n * @api public\n */\n\nfunction Emitter(obj) {\n  if (obj) return mixin(obj);\n};\n\n/**\n * Mixin the emitter properties.\n *\n * @param {Object} obj\n * @return {Object}\n * @api private\n */\n\nfunction mixin(obj) {\n  for (var key in Emitter.prototype) {\n    obj[key] = Emitter.prototype[key];\n  }\n  return obj;\n}\n\n/**\n * Listen on the given `event` with `fn`.\n *\n * @param {String} event\n * @param {Function} fn\n * @return {Emitter}\n * @api public\n */\n\nEmitter.prototype.on =\nEmitter.prototype.addEventListener = function(event, fn){\n  this._callbacks = this._callbacks || {};\n  (this._callbacks[event] = this._callbacks[event] || [])\n    .push(fn);\n  return this;\n};\n\n/**\n * Adds an `event` listener that will be invoked a single\n * time then automatically removed.\n *\n * @param {String} event\n * @param {Function} fn\n * @return {Emitter}\n * @api public\n */\n\nEmitter.prototype.once = function(event, fn){\n  var self = this;\n  this._callbacks = this._callbacks || {};\n\n  function on() {\n    self.off(event, on);\n    fn.apply(this, arguments);\n  }\n\n  on.fn = fn;\n  this.on(event, on);\n  return this;\n};\n\n/**\n * Remove the given callback for `event` or all\n * registered callbacks.\n *\n * @param {String} event\n * @param {Function} fn\n * @return {Emitter}\n * @api public\n */\n\nEmitter.prototype.off =\nEmitter.prototype.removeListener =\nEmitter.prototype.removeAllListeners =\nEmitter.prototype.removeEventListener = function(event, fn){\n  this._callbacks = this._callbacks || {};\n\n  // all\n  if (0 == arguments.length) {\n    this._callbacks = {};\n    return this;\n  }\n\n  // specific event\n  var callbacks = this._callbacks[event];\n  if (!callbacks) return this;\n\n  // remove all handlers\n  if (1 == arguments.length) {\n    delete this._callbacks[event];\n    return this;\n  }\n\n  // remove specific handler\n  var cb;\n  for (var i = 0; i < callbacks.length; i++) {\n    cb = callbacks[i];\n    if (cb === fn || cb.fn === fn) {\n      callbacks.splice(i, 1);\n      break;\n    }\n  }\n  return this;\n};\n\n/**\n * Emit `event` with the given args.\n *\n * @param {String} event\n * @param {Mixed} ...\n * @return {Emitter}\n */\n\nEmitter.prototype.emit = function(event){\n  this._callbacks = this._callbacks || {};\n  var args = [].slice.call(arguments, 1)\n    , callbacks = this._callbacks[event];\n\n  if (callbacks) {\n    callbacks = callbacks.slice(0);\n    for (var i = 0, len = callbacks.length; i < len; ++i) {\n      callbacks[i].apply(this, args);\n    }\n  }\n\n  return this;\n};\n\n/**\n * Return array of callbacks for `event`.\n *\n * @param {String} event\n * @return {Array}\n * @api public\n */\n\nEmitter.prototype.listeners = function(event){\n  this._callbacks = this._callbacks || {};\n  return this._callbacks[event] || [];\n};\n\n/**\n * Check if this emitter has `event` handlers.\n *\n * @param {String} event\n * @return {Boolean}\n * @api public\n */\n\nEmitter.prototype.hasListeners = function(event){\n  return !! this.listeners(event).length;\n};\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ../~/component-emitter/index.js\n// module id = 459\n// module chunks = 1 4 8 9 11","/*global Blob,File*/\n\n/**\n * Module requirements\n */\n\nvar isArray = require('isarray');\nvar isBuf = require('./is-buffer');\n\n/**\n * Replaces every Buffer | ArrayBuffer in packet with a numbered placeholder.\n * Anything with blobs or files should be fed through removeBlobs before coming\n * here.\n *\n * @param {Object} packet - socket.io event packet\n * @return {Object} with deconstructed packet and list of buffers\n * @api public\n */\n\nexports.deconstructPacket = function(packet){\n  var buffers = [];\n  var packetData = packet.data;\n\n  function _deconstructPacket(data) {\n    if (!data) return data;\n\n    if (isBuf(data)) {\n      var placeholder = { _placeholder: true, num: buffers.length };\n      buffers.push(data);\n      return placeholder;\n    } else if (isArray(data)) {\n      var newData = new Array(data.length);\n      for (var i = 0; i < data.length; i++) {\n        newData[i] = _deconstructPacket(data[i]);\n      }\n      return newData;\n    } else if ('object' == typeof data && !(data instanceof Date)) {\n      var newData = {};\n      for (var key in data) {\n        newData[key] = _deconstructPacket(data[key]);\n      }\n      return newData;\n    }\n    return data;\n  }\n\n  var pack = packet;\n  pack.data = _deconstructPacket(packetData);\n  pack.attachments = buffers.length; // number of binary 'attachments'\n  return {packet: pack, buffers: buffers};\n};\n\n/**\n * Reconstructs a binary packet from its placeholder packet and buffers\n *\n * @param {Object} packet - event packet with placeholders\n * @param {Array} buffers - binary buffers to put in placeholder positions\n * @return {Object} reconstructed packet\n * @api public\n */\n\nexports.reconstructPacket = function(packet, buffers) {\n  var curPlaceHolder = 0;\n\n  function _reconstructPacket(data) {\n    if (data && data._placeholder) {\n      var buf = buffers[data.num]; // appropriate buffer (should be natural order anyway)\n      return buf;\n    } else if (isArray(data)) {\n      for (var i = 0; i < data.length; i++) {\n        data[i] = _reconstructPacket(data[i]);\n      }\n      return data;\n    } else if (data && 'object' == typeof data) {\n      for (var key in data) {\n        data[key] = _reconstructPacket(data[key]);\n      }\n      return data;\n    }\n    return data;\n  }\n\n  packet.data = _reconstructPacket(packet.data);\n  packet.attachments = undefined; // no longer useful\n  return packet;\n};\n\n/**\n * Asynchronously removes Blobs or Files from data via\n * FileReader's readAsArrayBuffer method. Used before encoding\n * data as msgpack. Calls callback with the blobless data.\n *\n * @param {Object} data\n * @param {Function} callback\n * @api private\n */\n\nexports.removeBlobs = function(data, callback) {\n  function _removeBlobs(obj, curKey, containingObject) {\n    if (!obj) return obj;\n\n    // convert any blob\n    if ((global.Blob && obj instanceof Blob) ||\n        (global.File && obj instanceof File)) {\n      pendingBlobs++;\n\n      // async filereader\n      var fileReader = new FileReader();\n      fileReader.onload = function() { // this.result == arraybuffer\n        if (containingObject) {\n          containingObject[curKey] = this.result;\n        }\n        else {\n          bloblessData = this.result;\n        }\n\n        // if nothing pending its callback time\n        if(! --pendingBlobs) {\n          callback(bloblessData);\n        }\n      };\n\n      fileReader.readAsArrayBuffer(obj); // blob -> arraybuffer\n    } else if (isArray(obj)) { // handle array\n      for (var i = 0; i < obj.length; i++) {\n        _removeBlobs(obj[i], i, obj);\n      }\n    } else if (obj && 'object' == typeof obj && !isBuf(obj)) { // and object\n      for (var key in obj) {\n        _removeBlobs(obj[key], key, obj);\n      }\n    }\n  }\n\n  var pendingBlobs = 0;\n  var bloblessData = data;\n  _removeBlobs(bloblessData);\n  if (!pendingBlobs) {\n    callback(bloblessData);\n  }\n};\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ../~/socket.io-parser/binary.js\n// module id = 460\n// module chunks = 1 4 8 9 11","module.exports = Array.isArray || function (arr) {\n  return Object.prototype.toString.call(arr) == '[object Array]';\n};\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ../~/socket.io-parser/~/isarray/index.js\n// module id = 461\n// module chunks = 1 4 8 9 11","\nmodule.exports = isBuf;\n\n/**\n * Returns true if obj is a buffer or an arraybuffer.\n *\n * @api private\n */\n\nfunction isBuf(obj) {\n  return (global.Buffer && global.Buffer.isBuffer(obj)) ||\n         (global.ArrayBuffer && obj instanceof ArrayBuffer);\n}\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ../~/socket.io-parser/is-buffer.js\n// module id = 462\n// module chunks = 1 4 8 9 11","\n/**\n * Module dependencies.\n */\n\nvar eio = require('engine.io-client');\nvar Socket = require('./socket');\nvar Emitter = require('component-emitter');\nvar parser = require('socket.io-parser');\nvar on = require('./on');\nvar bind = require('component-bind');\nvar debug = require('debug')('socket.io-client:manager');\nvar indexOf = require('indexof');\nvar Backoff = require('backo2');\n\n/**\n * IE6+ hasOwnProperty\n */\n\nvar has = Object.prototype.hasOwnProperty;\n\n/**\n * Module exports\n */\n\nmodule.exports = Manager;\n\n/**\n * `Manager` constructor.\n *\n * @param {String} engine instance or engine uri/opts\n * @param {Object} options\n * @api public\n */\n\nfunction Manager (uri, opts) {\n  if (!(this instanceof Manager)) return new Manager(uri, opts);\n  if (uri && ('object' === typeof uri)) {\n    opts = uri;\n    uri = undefined;\n  }\n  opts = opts || {};\n\n  opts.path = opts.path || '/socket.io';\n  this.nsps = {};\n  this.subs = [];\n  this.opts = opts;\n  this.reconnection(opts.reconnection !== false);\n  this.reconnectionAttempts(opts.reconnectionAttempts || Infinity);\n  this.reconnectionDelay(opts.reconnectionDelay || 1000);\n  this.reconnectionDelayMax(opts.reconnectionDelayMax || 5000);\n  this.randomizationFactor(opts.randomizationFactor || 0.5);\n  this.backoff = new Backoff({\n    min: this.reconnectionDelay(),\n    max: this.reconnectionDelayMax(),\n    jitter: this.randomizationFactor()\n  });\n  this.timeout(null == opts.timeout ? 20000 : opts.timeout);\n  this.readyState = 'closed';\n  this.uri = uri;\n  this.connecting = [];\n  this.lastPing = null;\n  this.encoding = false;\n  this.packetBuffer = [];\n  this.encoder = new parser.Encoder();\n  this.decoder = new parser.Decoder();\n  this.autoConnect = opts.autoConnect !== false;\n  if (this.autoConnect) this.open();\n}\n\n/**\n * Propagate given event to sockets and emit on `this`\n *\n * @api private\n */\n\nManager.prototype.emitAll = function () {\n  this.emit.apply(this, arguments);\n  for (var nsp in this.nsps) {\n    if (has.call(this.nsps, nsp)) {\n      this.nsps[nsp].emit.apply(this.nsps[nsp], arguments);\n    }\n  }\n};\n\n/**\n * Update `socket.id` of all sockets\n *\n * @api private\n */\n\nManager.prototype.updateSocketIds = function () {\n  for (var nsp in this.nsps) {\n    if (has.call(this.nsps, nsp)) {\n      this.nsps[nsp].id = this.engine.id;\n    }\n  }\n};\n\n/**\n * Mix in `Emitter`.\n */\n\nEmitter(Manager.prototype);\n\n/**\n * Sets the `reconnection` config.\n *\n * @param {Boolean} true/false if it should automatically reconnect\n * @return {Manager} self or value\n * @api public\n */\n\nManager.prototype.reconnection = function (v) {\n  if (!arguments.length) return this._reconnection;\n  this._reconnection = !!v;\n  return this;\n};\n\n/**\n * Sets the reconnection attempts config.\n *\n * @param {Number} max reconnection attempts before giving up\n * @return {Manager} self or value\n * @api public\n */\n\nManager.prototype.reconnectionAttempts = function (v) {\n  if (!arguments.length) return this._reconnectionAttempts;\n  this._reconnectionAttempts = v;\n  return this;\n};\n\n/**\n * Sets the delay between reconnections.\n *\n * @param {Number} delay\n * @return {Manager} self or value\n * @api public\n */\n\nManager.prototype.reconnectionDelay = function (v) {\n  if (!arguments.length) return this._reconnectionDelay;\n  this._reconnectionDelay = v;\n  this.backoff && this.backoff.setMin(v);\n  return this;\n};\n\nManager.prototype.randomizationFactor = function (v) {\n  if (!arguments.length) return this._randomizationFactor;\n  this._randomizationFactor = v;\n  this.backoff && this.backoff.setJitter(v);\n  return this;\n};\n\n/**\n * Sets the maximum delay between reconnections.\n *\n * @param {Number} delay\n * @return {Manager} self or value\n * @api public\n */\n\nManager.prototype.reconnectionDelayMax = function (v) {\n  if (!arguments.length) return this._reconnectionDelayMax;\n  this._reconnectionDelayMax = v;\n  this.backoff && this.backoff.setMax(v);\n  return this;\n};\n\n/**\n * Sets the connection timeout. `false` to disable\n *\n * @return {Manager} self or value\n * @api public\n */\n\nManager.prototype.timeout = function (v) {\n  if (!arguments.length) return this._timeout;\n  this._timeout = v;\n  return this;\n};\n\n/**\n * Starts trying to reconnect if reconnection is enabled and we have not\n * started reconnecting yet\n *\n * @api private\n */\n\nManager.prototype.maybeReconnectOnOpen = function () {\n  // Only try to reconnect if it's the first time we're connecting\n  if (!this.reconnecting && this._reconnection && this.backoff.attempts === 0) {\n    // keeps reconnection from firing twice for the same reconnection loop\n    this.reconnect();\n  }\n};\n\n/**\n * Sets the current transport `socket`.\n *\n * @param {Function} optional, callback\n * @return {Manager} self\n * @api public\n */\n\nManager.prototype.open =\nManager.prototype.connect = function (fn, opts) {\n  debug('readyState %s', this.readyState);\n  if (~this.readyState.indexOf('open')) return this;\n\n  debug('opening %s', this.uri);\n  this.engine = eio(this.uri, this.opts);\n  var socket = this.engine;\n  var self = this;\n  this.readyState = 'opening';\n  this.skipReconnect = false;\n\n  // emit `open`\n  var openSub = on(socket, 'open', function () {\n    self.onopen();\n    fn && fn();\n  });\n\n  // emit `connect_error`\n  var errorSub = on(socket, 'error', function (data) {\n    debug('connect_error');\n    self.cleanup();\n    self.readyState = 'closed';\n    self.emitAll('connect_error', data);\n    if (fn) {\n      var err = new Error('Connection error');\n      err.data = data;\n      fn(err);\n    } else {\n      // Only do this if there is no fn to handle the error\n      self.maybeReconnectOnOpen();\n    }\n  });\n\n  // emit `connect_timeout`\n  if (false !== this._timeout) {\n    var timeout = this._timeout;\n    debug('connect attempt will timeout after %d', timeout);\n\n    // set timer\n    var timer = setTimeout(function () {\n      debug('connect attempt timed out after %d', timeout);\n      openSub.destroy();\n      socket.close();\n      socket.emit('error', 'timeout');\n      self.emitAll('connect_timeout', timeout);\n    }, timeout);\n\n    this.subs.push({\n      destroy: function () {\n        clearTimeout(timer);\n      }\n    });\n  }\n\n  this.subs.push(openSub);\n  this.subs.push(errorSub);\n\n  return this;\n};\n\n/**\n * Called upon transport open.\n *\n * @api private\n */\n\nManager.prototype.onopen = function () {\n  debug('open');\n\n  // clear old subs\n  this.cleanup();\n\n  // mark as open\n  this.readyState = 'open';\n  this.emit('open');\n\n  // add new subs\n  var socket = this.engine;\n  this.subs.push(on(socket, 'data', bind(this, 'ondata')));\n  this.subs.push(on(socket, 'ping', bind(this, 'onping')));\n  this.subs.push(on(socket, 'pong', bind(this, 'onpong')));\n  this.subs.push(on(socket, 'error', bind(this, 'onerror')));\n  this.subs.push(on(socket, 'close', bind(this, 'onclose')));\n  this.subs.push(on(this.decoder, 'decoded', bind(this, 'ondecoded')));\n};\n\n/**\n * Called upon a ping.\n *\n * @api private\n */\n\nManager.prototype.onping = function () {\n  this.lastPing = new Date();\n  this.emitAll('ping');\n};\n\n/**\n * Called upon a packet.\n *\n * @api private\n */\n\nManager.prototype.onpong = function () {\n  this.emitAll('pong', new Date() - this.lastPing);\n};\n\n/**\n * Called with data.\n *\n * @api private\n */\n\nManager.prototype.ondata = function (data) {\n  this.decoder.add(data);\n};\n\n/**\n * Called when parser fully decodes a packet.\n *\n * @api private\n */\n\nManager.prototype.ondecoded = function (packet) {\n  this.emit('packet', packet);\n};\n\n/**\n * Called upon socket error.\n *\n * @api private\n */\n\nManager.prototype.onerror = function (err) {\n  debug('error', err);\n  this.emitAll('error', err);\n};\n\n/**\n * Creates a new socket for the given `nsp`.\n *\n * @return {Socket}\n * @api public\n */\n\nManager.prototype.socket = function (nsp, opts) {\n  var socket = this.nsps[nsp];\n  if (!socket) {\n    socket = new Socket(this, nsp, opts);\n    this.nsps[nsp] = socket;\n    var self = this;\n    socket.on('connecting', onConnecting);\n    socket.on('connect', function () {\n      socket.id = self.engine.id;\n    });\n\n    if (this.autoConnect) {\n      // manually call here since connecting evnet is fired before listening\n      onConnecting();\n    }\n  }\n\n  function onConnecting () {\n    if (!~indexOf(self.connecting, socket)) {\n      self.connecting.push(socket);\n    }\n  }\n\n  return socket;\n};\n\n/**\n * Called upon a socket close.\n *\n * @param {Socket} socket\n */\n\nManager.prototype.destroy = function (socket) {\n  var index = indexOf(this.connecting, socket);\n  if (~index) this.connecting.splice(index, 1);\n  if (this.connecting.length) return;\n\n  this.close();\n};\n\n/**\n * Writes a packet.\n *\n * @param {Object} packet\n * @api private\n */\n\nManager.prototype.packet = function (packet) {\n  debug('writing packet %j', packet);\n  var self = this;\n  if (packet.query && packet.type === 0) packet.nsp += '?' + packet.query;\n\n  if (!self.encoding) {\n    // encode, then write to engine with result\n    self.encoding = true;\n    this.encoder.encode(packet, function (encodedPackets) {\n      for (var i = 0; i < encodedPackets.length; i++) {\n        self.engine.write(encodedPackets[i], packet.options);\n      }\n      self.encoding = false;\n      self.processPacketQueue();\n    });\n  } else { // add packet to the queue\n    self.packetBuffer.push(packet);\n  }\n};\n\n/**\n * If packet buffer is non-empty, begins encoding the\n * next packet in line.\n *\n * @api private\n */\n\nManager.prototype.processPacketQueue = function () {\n  if (this.packetBuffer.length > 0 && !this.encoding) {\n    var pack = this.packetBuffer.shift();\n    this.packet(pack);\n  }\n};\n\n/**\n * Clean up transport subscriptions and packet buffer.\n *\n * @api private\n */\n\nManager.prototype.cleanup = function () {\n  debug('cleanup');\n\n  var subsLength = this.subs.length;\n  for (var i = 0; i < subsLength; i++) {\n    var sub = this.subs.shift();\n    sub.destroy();\n  }\n\n  this.packetBuffer = [];\n  this.encoding = false;\n  this.lastPing = null;\n\n  this.decoder.destroy();\n};\n\n/**\n * Close the current socket.\n *\n * @api private\n */\n\nManager.prototype.close =\nManager.prototype.disconnect = function () {\n  debug('disconnect');\n  this.skipReconnect = true;\n  this.reconnecting = false;\n  if ('opening' === this.readyState) {\n    // `onclose` will not fire because\n    // an open event never happened\n    this.cleanup();\n  }\n  this.backoff.reset();\n  this.readyState = 'closed';\n  if (this.engine) this.engine.close();\n};\n\n/**\n * Called upon engine close.\n *\n * @api private\n */\n\nManager.prototype.onclose = function (reason) {\n  debug('onclose');\n\n  this.cleanup();\n  this.backoff.reset();\n  this.readyState = 'closed';\n  this.emit('close', reason);\n\n  if (this._reconnection && !this.skipReconnect) {\n    this.reconnect();\n  }\n};\n\n/**\n * Attempt a reconnection.\n *\n * @api private\n */\n\nManager.prototype.reconnect = function () {\n  if (this.reconnecting || this.skipReconnect) return this;\n\n  var self = this;\n\n  if (this.backoff.attempts >= this._reconnectionAttempts) {\n    debug('reconnect failed');\n    this.backoff.reset();\n    this.emitAll('reconnect_failed');\n    this.reconnecting = false;\n  } else {\n    var delay = this.backoff.duration();\n    debug('will wait %dms before reconnect attempt', delay);\n\n    this.reconnecting = true;\n    var timer = setTimeout(function () {\n      if (self.skipReconnect) return;\n\n      debug('attempting reconnect');\n      self.emitAll('reconnect_attempt', self.backoff.attempts);\n      self.emitAll('reconnecting', self.backoff.attempts);\n\n      // check again for the case socket closed in above events\n      if (self.skipReconnect) return;\n\n      self.open(function (err) {\n        if (err) {\n          debug('reconnect attempt error');\n          self.reconnecting = false;\n          self.reconnect();\n          self.emitAll('reconnect_error', err.data);\n        } else {\n          debug('reconnect success');\n          self.onreconnect();\n        }\n      });\n    }, delay);\n\n    this.subs.push({\n      destroy: function () {\n        clearTimeout(timer);\n      }\n    });\n  }\n};\n\n/**\n * Called upon successful reconnect.\n *\n * @api private\n */\n\nManager.prototype.onreconnect = function () {\n  var attempt = this.backoff.attempts;\n  this.reconnecting = false;\n  this.backoff.reset();\n  this.updateSocketIds();\n  this.emitAll('reconnect', attempt);\n};\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ../~/socket.io-client/lib/manager.js\n// module id = 463\n// module chunks = 1 4 8 9 11","\nmodule.exports = require('./lib/index');\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ../~/engine.io-client/index.js\n// module id = 464\n// module chunks = 1 4 8 9 11","\nmodule.exports = require('./socket');\n\n/**\n * Exports parser\n *\n * @api public\n *\n */\nmodule.exports.parser = require('engine.io-parser');\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ../~/engine.io-client/lib/index.js\n// module id = 465\n// module chunks = 1 4 8 9 11","/**\n * Module dependencies.\n */\n\nvar transports = require('./transports/index');\nvar Emitter = require('component-emitter');\nvar debug = require('debug')('engine.io-client:socket');\nvar index = require('indexof');\nvar parser = require('engine.io-parser');\nvar parseuri = require('parseuri');\nvar parsejson = require('parsejson');\nvar parseqs = require('parseqs');\n\n/**\n * Module exports.\n */\n\nmodule.exports = Socket;\n\n/**\n * Socket constructor.\n *\n * @param {String|Object} uri or options\n * @param {Object} options\n * @api public\n */\n\nfunction Socket (uri, opts) {\n  if (!(this instanceof Socket)) return new Socket(uri, opts);\n\n  opts = opts || {};\n\n  if (uri && 'object' === typeof uri) {\n    opts = uri;\n    uri = null;\n  }\n\n  if (uri) {\n    uri = parseuri(uri);\n    opts.hostname = uri.host;\n    opts.secure = uri.protocol === 'https' || uri.protocol === 'wss';\n    opts.port = uri.port;\n    if (uri.query) opts.query = uri.query;\n  } else if (opts.host) {\n    opts.hostname = parseuri(opts.host).host;\n  }\n\n  this.secure = null != opts.secure ? opts.secure\n    : (global.location && 'https:' === location.protocol);\n\n  if (opts.hostname && !opts.port) {\n    // if no port is specified manually, use the protocol default\n    opts.port = this.secure ? '443' : '80';\n  }\n\n  this.agent = opts.agent || false;\n  this.hostname = opts.hostname ||\n    (global.location ? location.hostname : 'localhost');\n  this.port = opts.port || (global.location && location.port\n      ? location.port\n      : (this.secure ? 443 : 80));\n  this.query = opts.query || {};\n  if ('string' === typeof this.query) this.query = parseqs.decode(this.query);\n  this.upgrade = false !== opts.upgrade;\n  this.path = (opts.path || '/engine.io').replace(/\\/$/, '') + '/';\n  this.forceJSONP = !!opts.forceJSONP;\n  this.jsonp = false !== opts.jsonp;\n  this.forceBase64 = !!opts.forceBase64;\n  this.enablesXDR = !!opts.enablesXDR;\n  this.timestampParam = opts.timestampParam || 't';\n  this.timestampRequests = opts.timestampRequests;\n  this.transports = opts.transports || ['polling', 'websocket'];\n  this.readyState = '';\n  this.writeBuffer = [];\n  this.prevBufferLen = 0;\n  this.policyPort = opts.policyPort || 843;\n  this.rememberUpgrade = opts.rememberUpgrade || false;\n  this.binaryType = null;\n  this.onlyBinaryUpgrades = opts.onlyBinaryUpgrades;\n  this.perMessageDeflate = false !== opts.perMessageDeflate ? (opts.perMessageDeflate || {}) : false;\n\n  if (true === this.perMessageDeflate) this.perMessageDeflate = {};\n  if (this.perMessageDeflate && null == this.perMessageDeflate.threshold) {\n    this.perMessageDeflate.threshold = 1024;\n  }\n\n  // SSL options for Node.js client\n  this.pfx = opts.pfx || null;\n  this.key = opts.key || null;\n  this.passphrase = opts.passphrase || null;\n  this.cert = opts.cert || null;\n  this.ca = opts.ca || null;\n  this.ciphers = opts.ciphers || null;\n  this.rejectUnauthorized = opts.rejectUnauthorized === undefined ? null : opts.rejectUnauthorized;\n  this.forceNode = !!opts.forceNode;\n\n  // other options for Node.js client\n  var freeGlobal = typeof global === 'object' && global;\n  if (freeGlobal.global === freeGlobal) {\n    if (opts.extraHeaders && Object.keys(opts.extraHeaders).length > 0) {\n      this.extraHeaders = opts.extraHeaders;\n    }\n\n    if (opts.localAddress) {\n      this.localAddress = opts.localAddress;\n    }\n  }\n\n  // set on handshake\n  this.id = null;\n  this.upgrades = null;\n  this.pingInterval = null;\n  this.pingTimeout = null;\n\n  // set on heartbeat\n  this.pingIntervalTimer = null;\n  this.pingTimeoutTimer = null;\n\n  this.open();\n}\n\nSocket.priorWebsocketSuccess = false;\n\n/**\n * Mix in `Emitter`.\n */\n\nEmitter(Socket.prototype);\n\n/**\n * Protocol version.\n *\n * @api public\n */\n\nSocket.protocol = parser.protocol; // this is an int\n\n/**\n * Expose deps for legacy compatibility\n * and standalone browser access.\n */\n\nSocket.Socket = Socket;\nSocket.Transport = require('./transport');\nSocket.transports = require('./transports/index');\nSocket.parser = require('engine.io-parser');\n\n/**\n * Creates transport of the given type.\n *\n * @param {String} transport name\n * @return {Transport}\n * @api private\n */\n\nSocket.prototype.createTransport = function (name) {\n  debug('creating transport \"%s\"', name);\n  var query = clone(this.query);\n\n  // append engine.io protocol identifier\n  query.EIO = parser.protocol;\n\n  // transport name\n  query.transport = name;\n\n  // session id if we already have one\n  if (this.id) query.sid = this.id;\n\n  var transport = new transports[name]({\n    agent: this.agent,\n    hostname: this.hostname,\n    port: this.port,\n    secure: this.secure,\n    path: this.path,\n    query: query,\n    forceJSONP: this.forceJSONP,\n    jsonp: this.jsonp,\n    forceBase64: this.forceBase64,\n    enablesXDR: this.enablesXDR,\n    timestampRequests: this.timestampRequests,\n    timestampParam: this.timestampParam,\n    policyPort: this.policyPort,\n    socket: this,\n    pfx: this.pfx,\n    key: this.key,\n    passphrase: this.passphrase,\n    cert: this.cert,\n    ca: this.ca,\n    ciphers: this.ciphers,\n    rejectUnauthorized: this.rejectUnauthorized,\n    perMessageDeflate: this.perMessageDeflate,\n    extraHeaders: this.extraHeaders,\n    forceNode: this.forceNode,\n    localAddress: this.localAddress\n  });\n\n  return transport;\n};\n\nfunction clone (obj) {\n  var o = {};\n  for (var i in obj) {\n    if (obj.hasOwnProperty(i)) {\n      o[i] = obj[i];\n    }\n  }\n  return o;\n}\n\n/**\n * Initializes transport to use and starts probe.\n *\n * @api private\n */\nSocket.prototype.open = function () {\n  var transport;\n  if (this.rememberUpgrade && Socket.priorWebsocketSuccess && this.transports.indexOf('websocket') !== -1) {\n    transport = 'websocket';\n  } else if (0 === this.transports.length) {\n    // Emit error on next tick so it can be listened to\n    var self = this;\n    setTimeout(function () {\n      self.emit('error', 'No transports available');\n    }, 0);\n    return;\n  } else {\n    transport = this.transports[0];\n  }\n  this.readyState = 'opening';\n\n  // Retry with the next transport if the transport is disabled (jsonp: false)\n  try {\n    transport = this.createTransport(transport);\n  } catch (e) {\n    this.transports.shift();\n    this.open();\n    return;\n  }\n\n  transport.open();\n  this.setTransport(transport);\n};\n\n/**\n * Sets the current transport. Disables the existing one (if any).\n *\n * @api private\n */\n\nSocket.prototype.setTransport = function (transport) {\n  debug('setting transport %s', transport.name);\n  var self = this;\n\n  if (this.transport) {\n    debug('clearing existing transport %s', this.transport.name);\n    this.transport.removeAllListeners();\n  }\n\n  // set up transport\n  this.transport = transport;\n\n  // set up transport listeners\n  transport\n  .on('drain', function () {\n    self.onDrain();\n  })\n  .on('packet', function (packet) {\n    self.onPacket(packet);\n  })\n  .on('error', function (e) {\n    self.onError(e);\n  })\n  .on('close', function () {\n    self.onClose('transport close');\n  });\n};\n\n/**\n * Probes a transport.\n *\n * @param {String} transport name\n * @api private\n */\n\nSocket.prototype.probe = function (name) {\n  debug('probing transport \"%s\"', name);\n  var transport = this.createTransport(name, { probe: 1 });\n  var failed = false;\n  var self = this;\n\n  Socket.priorWebsocketSuccess = false;\n\n  function onTransportOpen () {\n    if (self.onlyBinaryUpgrades) {\n      var upgradeLosesBinary = !this.supportsBinary && self.transport.supportsBinary;\n      failed = failed || upgradeLosesBinary;\n    }\n    if (failed) return;\n\n    debug('probe transport \"%s\" opened', name);\n    transport.send([{ type: 'ping', data: 'probe' }]);\n    transport.once('packet', function (msg) {\n      if (failed) return;\n      if ('pong' === msg.type && 'probe' === msg.data) {\n        debug('probe transport \"%s\" pong', name);\n        self.upgrading = true;\n        self.emit('upgrading', transport);\n        if (!transport) return;\n        Socket.priorWebsocketSuccess = 'websocket' === transport.name;\n\n        debug('pausing current transport \"%s\"', self.transport.name);\n        self.transport.pause(function () {\n          if (failed) return;\n          if ('closed' === self.readyState) return;\n          debug('changing transport and sending upgrade packet');\n\n          cleanup();\n\n          self.setTransport(transport);\n          transport.send([{ type: 'upgrade' }]);\n          self.emit('upgrade', transport);\n          transport = null;\n          self.upgrading = false;\n          self.flush();\n        });\n      } else {\n        debug('probe transport \"%s\" failed', name);\n        var err = new Error('probe error');\n        err.transport = transport.name;\n        self.emit('upgradeError', err);\n      }\n    });\n  }\n\n  function freezeTransport () {\n    if (failed) return;\n\n    // Any callback called by transport should be ignored since now\n    failed = true;\n\n    cleanup();\n\n    transport.close();\n    transport = null;\n  }\n\n  // Handle any error that happens while probing\n  function onerror (err) {\n    var error = new Error('probe error: ' + err);\n    error.transport = transport.name;\n\n    freezeTransport();\n\n    debug('probe transport \"%s\" failed because of error: %s', name, err);\n\n    self.emit('upgradeError', error);\n  }\n\n  function onTransportClose () {\n    onerror('transport closed');\n  }\n\n  // When the socket is closed while we're probing\n  function onclose () {\n    onerror('socket closed');\n  }\n\n  // When the socket is upgraded while we're probing\n  function onupgrade (to) {\n    if (transport && to.name !== transport.name) {\n      debug('\"%s\" works - aborting \"%s\"', to.name, transport.name);\n      freezeTransport();\n    }\n  }\n\n  // Remove all listeners on the transport and on self\n  function cleanup () {\n    transport.removeListener('open', onTransportOpen);\n    transport.removeListener('error', onerror);\n    transport.removeListener('close', onTransportClose);\n    self.removeListener('close', onclose);\n    self.removeListener('upgrading', onupgrade);\n  }\n\n  transport.once('open', onTransportOpen);\n  transport.once('error', onerror);\n  transport.once('close', onTransportClose);\n\n  this.once('close', onclose);\n  this.once('upgrading', onupgrade);\n\n  transport.open();\n};\n\n/**\n * Called when connection is deemed open.\n *\n * @api public\n */\n\nSocket.prototype.onOpen = function () {\n  debug('socket open');\n  this.readyState = 'open';\n  Socket.priorWebsocketSuccess = 'websocket' === this.transport.name;\n  this.emit('open');\n  this.flush();\n\n  // we check for `readyState` in case an `open`\n  // listener already closed the socket\n  if ('open' === this.readyState && this.upgrade && this.transport.pause) {\n    debug('starting upgrade probes');\n    for (var i = 0, l = this.upgrades.length; i < l; i++) {\n      this.probe(this.upgrades[i]);\n    }\n  }\n};\n\n/**\n * Handles a packet.\n *\n * @api private\n */\n\nSocket.prototype.onPacket = function (packet) {\n  if ('opening' === this.readyState || 'open' === this.readyState ||\n      'closing' === this.readyState) {\n    debug('socket receive: type \"%s\", data \"%s\"', packet.type, packet.data);\n\n    this.emit('packet', packet);\n\n    // Socket is live - any packet counts\n    this.emit('heartbeat');\n\n    switch (packet.type) {\n      case 'open':\n        this.onHandshake(parsejson(packet.data));\n        break;\n\n      case 'pong':\n        this.setPing();\n        this.emit('pong');\n        break;\n\n      case 'error':\n        var err = new Error('server error');\n        err.code = packet.data;\n        this.onError(err);\n        break;\n\n      case 'message':\n        this.emit('data', packet.data);\n        this.emit('message', packet.data);\n        break;\n    }\n  } else {\n    debug('packet received with socket readyState \"%s\"', this.readyState);\n  }\n};\n\n/**\n * Called upon handshake completion.\n *\n * @param {Object} handshake obj\n * @api private\n */\n\nSocket.prototype.onHandshake = function (data) {\n  this.emit('handshake', data);\n  this.id = data.sid;\n  this.transport.query.sid = data.sid;\n  this.upgrades = this.filterUpgrades(data.upgrades);\n  this.pingInterval = data.pingInterval;\n  this.pingTimeout = data.pingTimeout;\n  this.onOpen();\n  // In case open handler closes socket\n  if ('closed' === this.readyState) return;\n  this.setPing();\n\n  // Prolong liveness of socket on heartbeat\n  this.removeListener('heartbeat', this.onHeartbeat);\n  this.on('heartbeat', this.onHeartbeat);\n};\n\n/**\n * Resets ping timeout.\n *\n * @api private\n */\n\nSocket.prototype.onHeartbeat = function (timeout) {\n  clearTimeout(this.pingTimeoutTimer);\n  var self = this;\n  self.pingTimeoutTimer = setTimeout(function () {\n    if ('closed' === self.readyState) return;\n    self.onClose('ping timeout');\n  }, timeout || (self.pingInterval + self.pingTimeout));\n};\n\n/**\n * Pings server every `this.pingInterval` and expects response\n * within `this.pingTimeout` or closes connection.\n *\n * @api private\n */\n\nSocket.prototype.setPing = function () {\n  var self = this;\n  clearTimeout(self.pingIntervalTimer);\n  self.pingIntervalTimer = setTimeout(function () {\n    debug('writing ping packet - expecting pong within %sms', self.pingTimeout);\n    self.ping();\n    self.onHeartbeat(self.pingTimeout);\n  }, self.pingInterval);\n};\n\n/**\n* Sends a ping packet.\n*\n* @api private\n*/\n\nSocket.prototype.ping = function () {\n  var self = this;\n  this.sendPacket('ping', function () {\n    self.emit('ping');\n  });\n};\n\n/**\n * Called on `drain` event\n *\n * @api private\n */\n\nSocket.prototype.onDrain = function () {\n  this.writeBuffer.splice(0, this.prevBufferLen);\n\n  // setting prevBufferLen = 0 is very important\n  // for example, when upgrading, upgrade packet is sent over,\n  // and a nonzero prevBufferLen could cause problems on `drain`\n  this.prevBufferLen = 0;\n\n  if (0 === this.writeBuffer.length) {\n    this.emit('drain');\n  } else {\n    this.flush();\n  }\n};\n\n/**\n * Flush write buffers.\n *\n * @api private\n */\n\nSocket.prototype.flush = function () {\n  if ('closed' !== this.readyState && this.transport.writable &&\n    !this.upgrading && this.writeBuffer.length) {\n    debug('flushing %d packets in socket', this.writeBuffer.length);\n    this.transport.send(this.writeBuffer);\n    // keep track of current length of writeBuffer\n    // splice writeBuffer and callbackBuffer on `drain`\n    this.prevBufferLen = this.writeBuffer.length;\n    this.emit('flush');\n  }\n};\n\n/**\n * Sends a message.\n *\n * @param {String} message.\n * @param {Function} callback function.\n * @param {Object} options.\n * @return {Socket} for chaining.\n * @api public\n */\n\nSocket.prototype.write =\nSocket.prototype.send = function (msg, options, fn) {\n  this.sendPacket('message', msg, options, fn);\n  return this;\n};\n\n/**\n * Sends a packet.\n *\n * @param {String} packet type.\n * @param {String} data.\n * @param {Object} options.\n * @param {Function} callback function.\n * @api private\n */\n\nSocket.prototype.sendPacket = function (type, data, options, fn) {\n  if ('function' === typeof data) {\n    fn = data;\n    data = undefined;\n  }\n\n  if ('function' === typeof options) {\n    fn = options;\n    options = null;\n  }\n\n  if ('closing' === this.readyState || 'closed' === this.readyState) {\n    return;\n  }\n\n  options = options || {};\n  options.compress = false !== options.compress;\n\n  var packet = {\n    type: type,\n    data: data,\n    options: options\n  };\n  this.emit('packetCreate', packet);\n  this.writeBuffer.push(packet);\n  if (fn) this.once('flush', fn);\n  this.flush();\n};\n\n/**\n * Closes the connection.\n *\n * @api private\n */\n\nSocket.prototype.close = function () {\n  if ('opening' === this.readyState || 'open' === this.readyState) {\n    this.readyState = 'closing';\n\n    var self = this;\n\n    if (this.writeBuffer.length) {\n      this.once('drain', function () {\n        if (this.upgrading) {\n          waitForUpgrade();\n        } else {\n          close();\n        }\n      });\n    } else if (this.upgrading) {\n      waitForUpgrade();\n    } else {\n      close();\n    }\n  }\n\n  function close () {\n    self.onClose('forced close');\n    debug('socket closing - telling transport to close');\n    self.transport.close();\n  }\n\n  function cleanupAndClose () {\n    self.removeListener('upgrade', cleanupAndClose);\n    self.removeListener('upgradeError', cleanupAndClose);\n    close();\n  }\n\n  function waitForUpgrade () {\n    // wait for upgrade to finish since we can't send packets while pausing a transport\n    self.once('upgrade', cleanupAndClose);\n    self.once('upgradeError', cleanupAndClose);\n  }\n\n  return this;\n};\n\n/**\n * Called upon transport error\n *\n * @api private\n */\n\nSocket.prototype.onError = function (err) {\n  debug('socket error %j', err);\n  Socket.priorWebsocketSuccess = false;\n  this.emit('error', err);\n  this.onClose('transport error', err);\n};\n\n/**\n * Called upon transport close.\n *\n * @api private\n */\n\nSocket.prototype.onClose = function (reason, desc) {\n  if ('opening' === this.readyState || 'open' === this.readyState || 'closing' === this.readyState) {\n    debug('socket close with reason: \"%s\"', reason);\n    var self = this;\n\n    // clear timers\n    clearTimeout(this.pingIntervalTimer);\n    clearTimeout(this.pingTimeoutTimer);\n\n    // stop event from firing again for transport\n    this.transport.removeAllListeners('close');\n\n    // ensure transport won't stay open\n    this.transport.close();\n\n    // ignore further transport communication\n    this.transport.removeAllListeners();\n\n    // set ready state\n    this.readyState = 'closed';\n\n    // clear session id\n    this.id = null;\n\n    // emit close event\n    this.emit('close', reason, desc);\n\n    // clean buffers after, so users can still\n    // grab the buffers on `close` event\n    self.writeBuffer = [];\n    self.prevBufferLen = 0;\n  }\n};\n\n/**\n * Filters upgrades, returning only those matching client transports.\n *\n * @param {Array} server upgrades\n * @api private\n *\n */\n\nSocket.prototype.filterUpgrades = function (upgrades) {\n  var filteredUpgrades = [];\n  for (var i = 0, j = upgrades.length; i < j; i++) {\n    if (~index(this.transports, upgrades[i])) filteredUpgrades.push(upgrades[i]);\n  }\n  return filteredUpgrades;\n};\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ../~/engine.io-client/lib/socket.js\n// module id = 466\n// module chunks = 1 4 8 9 11","/**\n * Module dependencies\n */\n\nvar XMLHttpRequest = require('xmlhttprequest-ssl');\nvar XHR = require('./polling-xhr');\nvar JSONP = require('./polling-jsonp');\nvar websocket = require('./websocket');\n\n/**\n * Export transports.\n */\n\nexports.polling = polling;\nexports.websocket = websocket;\n\n/**\n * Polling transport polymorphic constructor.\n * Decides on xhr vs jsonp based on feature detection.\n *\n * @api private\n */\n\nfunction polling (opts) {\n  var xhr;\n  var xd = false;\n  var xs = false;\n  var jsonp = false !== opts.jsonp;\n\n  if (global.location) {\n    var isSSL = 'https:' === location.protocol;\n    var port = location.port;\n\n    // some user agents have empty `location.port`\n    if (!port) {\n      port = isSSL ? 443 : 80;\n    }\n\n    xd = opts.hostname !== location.hostname || port !== opts.port;\n    xs = opts.secure !== isSSL;\n  }\n\n  opts.xdomain = xd;\n  opts.xscheme = xs;\n  xhr = new XMLHttpRequest(opts);\n\n  if ('open' in xhr && !opts.forceJSONP) {\n    return new XHR(opts);\n  } else {\n    if (!jsonp) throw new Error('JSONP disabled');\n    return new JSONP(opts);\n  }\n}\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ../~/engine.io-client/lib/transports/index.js\n// module id = 467\n// module chunks = 1 4 8 9 11","// browser shim for xmlhttprequest module\n\nvar hasCORS = require('has-cors');\n\nmodule.exports = function (opts) {\n  var xdomain = opts.xdomain;\n\n  // scheme must be same when usign XDomainRequest\n  // http://blogs.msdn.com/b/ieinternals/archive/2010/05/13/xdomainrequest-restrictions-limitations-and-workarounds.aspx\n  var xscheme = opts.xscheme;\n\n  // XDomainRequest has a flow of not sending cookie, therefore it should be disabled as a default.\n  // https://github.com/Automattic/engine.io-client/pull/217\n  var enablesXDR = opts.enablesXDR;\n\n  // XMLHttpRequest can be disabled on IE\n  try {\n    if ('undefined' !== typeof XMLHttpRequest && (!xdomain || hasCORS)) {\n      return new XMLHttpRequest();\n    }\n  } catch (e) { }\n\n  // Use XDomainRequest for IE8 if enablesXDR is true\n  // because loading bar keeps flashing when using jsonp-polling\n  // https://github.com/yujiosaka/socke.io-ie8-loading-example\n  try {\n    if ('undefined' !== typeof XDomainRequest && !xscheme && enablesXDR) {\n      return new XDomainRequest();\n    }\n  } catch (e) { }\n\n  if (!xdomain) {\n    try {\n      return new global[['Active'].concat('Object').join('X')]('Microsoft.XMLHTTP');\n    } catch (e) { }\n  }\n};\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ../~/engine.io-client/lib/xmlhttprequest.js\n// module id = 468\n// module chunks = 1 4 8 9 11","\n/**\n * Module exports.\n *\n * Logic borrowed from Modernizr:\n *\n *   - https://github.com/Modernizr/Modernizr/blob/master/feature-detects/cors.js\n */\n\ntry {\n  module.exports = typeof XMLHttpRequest !== 'undefined' &&\n    'withCredentials' in new XMLHttpRequest();\n} catch (err) {\n  // if XMLHttp support is disabled in IE then it will throw\n  // when trying to create\n  module.exports = false;\n}\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ../~/has-cors/index.js\n// module id = 469\n// module chunks = 1 4 8 9 11","/**\n * Module requirements.\n */\n\nvar XMLHttpRequest = require('xmlhttprequest-ssl');\nvar Polling = require('./polling');\nvar Emitter = require('component-emitter');\nvar inherit = require('component-inherit');\nvar debug = require('debug')('engine.io-client:polling-xhr');\n\n/**\n * Module exports.\n */\n\nmodule.exports = XHR;\nmodule.exports.Request = Request;\n\n/**\n * Empty function\n */\n\nfunction empty () {}\n\n/**\n * XHR Polling constructor.\n *\n * @param {Object} opts\n * @api public\n */\n\nfunction XHR (opts) {\n  Polling.call(this, opts);\n  this.requestTimeout = opts.requestTimeout;\n\n  if (global.location) {\n    var isSSL = 'https:' === location.protocol;\n    var port = location.port;\n\n    // some user agents have empty `location.port`\n    if (!port) {\n      port = isSSL ? 443 : 80;\n    }\n\n    this.xd = opts.hostname !== global.location.hostname ||\n      port !== opts.port;\n    this.xs = opts.secure !== isSSL;\n  } else {\n    this.extraHeaders = opts.extraHeaders;\n  }\n}\n\n/**\n * Inherits from Polling.\n */\n\ninherit(XHR, Polling);\n\n/**\n * XHR supports binary\n */\n\nXHR.prototype.supportsBinary = true;\n\n/**\n * Creates a request.\n *\n * @param {String} method\n * @api private\n */\n\nXHR.prototype.request = function (opts) {\n  opts = opts || {};\n  opts.uri = this.uri();\n  opts.xd = this.xd;\n  opts.xs = this.xs;\n  opts.agent = this.agent || false;\n  opts.supportsBinary = this.supportsBinary;\n  opts.enablesXDR = this.enablesXDR;\n\n  // SSL options for Node.js client\n  opts.pfx = this.pfx;\n  opts.key = this.key;\n  opts.passphrase = this.passphrase;\n  opts.cert = this.cert;\n  opts.ca = this.ca;\n  opts.ciphers = this.ciphers;\n  opts.rejectUnauthorized = this.rejectUnauthorized;\n  opts.requestTimeout = this.requestTimeout;\n\n  // other options for Node.js client\n  opts.extraHeaders = this.extraHeaders;\n\n  return new Request(opts);\n};\n\n/**\n * Sends data.\n *\n * @param {String} data to send.\n * @param {Function} called upon flush.\n * @api private\n */\n\nXHR.prototype.doWrite = function (data, fn) {\n  var isBinary = typeof data !== 'string' && data !== undefined;\n  var req = this.request({ method: 'POST', data: data, isBinary: isBinary });\n  var self = this;\n  req.on('success', fn);\n  req.on('error', function (err) {\n    self.onError('xhr post error', err);\n  });\n  this.sendXhr = req;\n};\n\n/**\n * Starts a poll cycle.\n *\n * @api private\n */\n\nXHR.prototype.doPoll = function () {\n  debug('xhr poll');\n  var req = this.request();\n  var self = this;\n  req.on('data', function (data) {\n    self.onData(data);\n  });\n  req.on('error', function (err) {\n    self.onError('xhr poll error', err);\n  });\n  this.pollXhr = req;\n};\n\n/**\n * Request constructor\n *\n * @param {Object} options\n * @api public\n */\n\nfunction Request (opts) {\n  this.method = opts.method || 'GET';\n  this.uri = opts.uri;\n  this.xd = !!opts.xd;\n  this.xs = !!opts.xs;\n  this.async = false !== opts.async;\n  this.data = undefined !== opts.data ? opts.data : null;\n  this.agent = opts.agent;\n  this.isBinary = opts.isBinary;\n  this.supportsBinary = opts.supportsBinary;\n  this.enablesXDR = opts.enablesXDR;\n  this.requestTimeout = opts.requestTimeout;\n\n  // SSL options for Node.js client\n  this.pfx = opts.pfx;\n  this.key = opts.key;\n  this.passphrase = opts.passphrase;\n  this.cert = opts.cert;\n  this.ca = opts.ca;\n  this.ciphers = opts.ciphers;\n  this.rejectUnauthorized = opts.rejectUnauthorized;\n\n  // other options for Node.js client\n  this.extraHeaders = opts.extraHeaders;\n\n  this.create();\n}\n\n/**\n * Mix in `Emitter`.\n */\n\nEmitter(Request.prototype);\n\n/**\n * Creates the XHR object and sends the request.\n *\n * @api private\n */\n\nRequest.prototype.create = function () {\n  var opts = { agent: this.agent, xdomain: this.xd, xscheme: this.xs, enablesXDR: this.enablesXDR };\n\n  // SSL options for Node.js client\n  opts.pfx = this.pfx;\n  opts.key = this.key;\n  opts.passphrase = this.passphrase;\n  opts.cert = this.cert;\n  opts.ca = this.ca;\n  opts.ciphers = this.ciphers;\n  opts.rejectUnauthorized = this.rejectUnauthorized;\n\n  var xhr = this.xhr = new XMLHttpRequest(opts);\n  var self = this;\n\n  try {\n    debug('xhr open %s: %s', this.method, this.uri);\n    xhr.open(this.method, this.uri, this.async);\n    try {\n      if (this.extraHeaders) {\n        xhr.setDisableHeaderCheck(true);\n        for (var i in this.extraHeaders) {\n          if (this.extraHeaders.hasOwnProperty(i)) {\n            xhr.setRequestHeader(i, this.extraHeaders[i]);\n          }\n        }\n      }\n    } catch (e) {}\n    if (this.supportsBinary) {\n      // This has to be done after open because Firefox is stupid\n      // http://stackoverflow.com/questions/13216903/get-binary-data-with-xmlhttprequest-in-a-firefox-extension\n      xhr.responseType = 'arraybuffer';\n    }\n\n    if ('POST' === this.method) {\n      try {\n        if (this.isBinary) {\n          xhr.setRequestHeader('Content-type', 'application/octet-stream');\n        } else {\n          xhr.setRequestHeader('Content-type', 'text/plain;charset=UTF-8');\n        }\n      } catch (e) {}\n    }\n\n    try {\n      xhr.setRequestHeader('Accept', '*/*');\n    } catch (e) {}\n\n    // ie6 check\n    if ('withCredentials' in xhr) {\n      xhr.withCredentials = true;\n    }\n\n    if (this.requestTimeout) {\n      xhr.timeout = this.requestTimeout;\n    }\n\n    if (this.hasXDR()) {\n      xhr.onload = function () {\n        self.onLoad();\n      };\n      xhr.onerror = function () {\n        self.onError(xhr.responseText);\n      };\n    } else {\n      xhr.onreadystatechange = function () {\n        if (4 !== xhr.readyState) return;\n        if (200 === xhr.status || 1223 === xhr.status) {\n          self.onLoad();\n        } else {\n          // make sure the `error` event handler that's user-set\n          // does not throw in the same tick and gets caught here\n          setTimeout(function () {\n            self.onError(xhr.status);\n          }, 0);\n        }\n      };\n    }\n\n    debug('xhr data %s', this.data);\n    xhr.send(this.data);\n  } catch (e) {\n    // Need to defer since .create() is called directly fhrom the constructor\n    // and thus the 'error' event can only be only bound *after* this exception\n    // occurs.  Therefore, also, we cannot throw here at all.\n    setTimeout(function () {\n      self.onError(e);\n    }, 0);\n    return;\n  }\n\n  if (global.document) {\n    this.index = Request.requestsCount++;\n    Request.requests[this.index] = this;\n  }\n};\n\n/**\n * Called upon successful response.\n *\n * @api private\n */\n\nRequest.prototype.onSuccess = function () {\n  this.emit('success');\n  this.cleanup();\n};\n\n/**\n * Called if we have data.\n *\n * @api private\n */\n\nRequest.prototype.onData = function (data) {\n  this.emit('data', data);\n  this.onSuccess();\n};\n\n/**\n * Called upon error.\n *\n * @api private\n */\n\nRequest.prototype.onError = function (err) {\n  this.emit('error', err);\n  this.cleanup(true);\n};\n\n/**\n * Cleans up house.\n *\n * @api private\n */\n\nRequest.prototype.cleanup = function (fromError) {\n  if ('undefined' === typeof this.xhr || null === this.xhr) {\n    return;\n  }\n  // xmlhttprequest\n  if (this.hasXDR()) {\n    this.xhr.onload = this.xhr.onerror = empty;\n  } else {\n    this.xhr.onreadystatechange = empty;\n  }\n\n  if (fromError) {\n    try {\n      this.xhr.abort();\n    } catch (e) {}\n  }\n\n  if (global.document) {\n    delete Request.requests[this.index];\n  }\n\n  this.xhr = null;\n};\n\n/**\n * Called upon load.\n *\n * @api private\n */\n\nRequest.prototype.onLoad = function () {\n  var data;\n  try {\n    var contentType;\n    try {\n      contentType = this.xhr.getResponseHeader('Content-Type').split(';')[0];\n    } catch (e) {}\n    if (contentType === 'application/octet-stream') {\n      data = this.xhr.response || this.xhr.responseText;\n    } else {\n      if (!this.supportsBinary) {\n        data = this.xhr.responseText;\n      } else {\n        try {\n          data = String.fromCharCode.apply(null, new Uint8Array(this.xhr.response));\n        } catch (e) {\n          var ui8Arr = new Uint8Array(this.xhr.response);\n          var dataArray = [];\n          for (var idx = 0, length = ui8Arr.length; idx < length; idx++) {\n            dataArray.push(ui8Arr[idx]);\n          }\n\n          data = String.fromCharCode.apply(null, dataArray);\n        }\n      }\n    }\n  } catch (e) {\n    this.onError(e);\n  }\n  if (null != data) {\n    this.onData(data);\n  }\n};\n\n/**\n * Check if it has XDomainRequest.\n *\n * @api private\n */\n\nRequest.prototype.hasXDR = function () {\n  return 'undefined' !== typeof global.XDomainRequest && !this.xs && this.enablesXDR;\n};\n\n/**\n * Aborts the request.\n *\n * @api public\n */\n\nRequest.prototype.abort = function () {\n  this.cleanup();\n};\n\n/**\n * Aborts pending requests when unloading the window. This is needed to prevent\n * memory leaks (e.g. when using IE) and to ensure that no spurious error is\n * emitted.\n */\n\nRequest.requestsCount = 0;\nRequest.requests = {};\n\nif (global.document) {\n  if (global.attachEvent) {\n    global.attachEvent('onunload', unloadHandler);\n  } else if (global.addEventListener) {\n    global.addEventListener('beforeunload', unloadHandler, false);\n  }\n}\n\nfunction unloadHandler () {\n  for (var i in Request.requests) {\n    if (Request.requests.hasOwnProperty(i)) {\n      Request.requests[i].abort();\n    }\n  }\n}\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ../~/engine.io-client/lib/transports/polling-xhr.js\n// module id = 470\n// module chunks = 1 4 8 9 11","/**\n * Module dependencies.\n */\n\nvar Transport = require('../transport');\nvar parseqs = require('parseqs');\nvar parser = require('engine.io-parser');\nvar inherit = require('component-inherit');\nvar yeast = require('yeast');\nvar debug = require('debug')('engine.io-client:polling');\n\n/**\n * Module exports.\n */\n\nmodule.exports = Polling;\n\n/**\n * Is XHR2 supported?\n */\n\nvar hasXHR2 = (function () {\n  var XMLHttpRequest = require('xmlhttprequest-ssl');\n  var xhr = new XMLHttpRequest({ xdomain: false });\n  return null != xhr.responseType;\n})();\n\n/**\n * Polling interface.\n *\n * @param {Object} opts\n * @api private\n */\n\nfunction Polling (opts) {\n  var forceBase64 = (opts && opts.forceBase64);\n  if (!hasXHR2 || forceBase64) {\n    this.supportsBinary = false;\n  }\n  Transport.call(this, opts);\n}\n\n/**\n * Inherits from Transport.\n */\n\ninherit(Polling, Transport);\n\n/**\n * Transport name.\n */\n\nPolling.prototype.name = 'polling';\n\n/**\n * Opens the socket (triggers polling). We write a PING message to determine\n * when the transport is open.\n *\n * @api private\n */\n\nPolling.prototype.doOpen = function () {\n  this.poll();\n};\n\n/**\n * Pauses polling.\n *\n * @param {Function} callback upon buffers are flushed and transport is paused\n * @api private\n */\n\nPolling.prototype.pause = function (onPause) {\n  var self = this;\n\n  this.readyState = 'pausing';\n\n  function pause () {\n    debug('paused');\n    self.readyState = 'paused';\n    onPause();\n  }\n\n  if (this.polling || !this.writable) {\n    var total = 0;\n\n    if (this.polling) {\n      debug('we are currently polling - waiting to pause');\n      total++;\n      this.once('pollComplete', function () {\n        debug('pre-pause polling complete');\n        --total || pause();\n      });\n    }\n\n    if (!this.writable) {\n      debug('we are currently writing - waiting to pause');\n      total++;\n      this.once('drain', function () {\n        debug('pre-pause writing complete');\n        --total || pause();\n      });\n    }\n  } else {\n    pause();\n  }\n};\n\n/**\n * Starts polling cycle.\n *\n * @api public\n */\n\nPolling.prototype.poll = function () {\n  debug('polling');\n  this.polling = true;\n  this.doPoll();\n  this.emit('poll');\n};\n\n/**\n * Overloads onData to detect payloads.\n *\n * @api private\n */\n\nPolling.prototype.onData = function (data) {\n  var self = this;\n  debug('polling got data %s', data);\n  var callback = function (packet, index, total) {\n    // if its the first message we consider the transport open\n    if ('opening' === self.readyState) {\n      self.onOpen();\n    }\n\n    // if its a close packet, we close the ongoing requests\n    if ('close' === packet.type) {\n      self.onClose();\n      return false;\n    }\n\n    // otherwise bypass onData and handle the message\n    self.onPacket(packet);\n  };\n\n  // decode payload\n  parser.decodePayload(data, this.socket.binaryType, callback);\n\n  // if an event did not trigger closing\n  if ('closed' !== this.readyState) {\n    // if we got data we're not polling\n    this.polling = false;\n    this.emit('pollComplete');\n\n    if ('open' === this.readyState) {\n      this.poll();\n    } else {\n      debug('ignoring poll - transport state \"%s\"', this.readyState);\n    }\n  }\n};\n\n/**\n * For polling, send a close packet.\n *\n * @api private\n */\n\nPolling.prototype.doClose = function () {\n  var self = this;\n\n  function close () {\n    debug('writing close packet');\n    self.write([{ type: 'close' }]);\n  }\n\n  if ('open' === this.readyState) {\n    debug('transport open - closing');\n    close();\n  } else {\n    // in case we're trying to close while\n    // handshaking is in progress (GH-164)\n    debug('transport not open - deferring close');\n    this.once('open', close);\n  }\n};\n\n/**\n * Writes a packets payload.\n *\n * @param {Array} data packets\n * @param {Function} drain callback\n * @api private\n */\n\nPolling.prototype.write = function (packets) {\n  var self = this;\n  this.writable = false;\n  var callbackfn = function () {\n    self.writable = true;\n    self.emit('drain');\n  };\n\n  parser.encodePayload(packets, this.supportsBinary, function (data) {\n    self.doWrite(data, callbackfn);\n  });\n};\n\n/**\n * Generates uri for connection.\n *\n * @api private\n */\n\nPolling.prototype.uri = function () {\n  var query = this.query || {};\n  var schema = this.secure ? 'https' : 'http';\n  var port = '';\n\n  // cache busting is forced\n  if (false !== this.timestampRequests) {\n    query[this.timestampParam] = yeast();\n  }\n\n  if (!this.supportsBinary && !query.sid) {\n    query.b64 = 1;\n  }\n\n  query = parseqs.encode(query);\n\n  // avoid port if default for schema\n  if (this.port && (('https' === schema && Number(this.port) !== 443) ||\n     ('http' === schema && Number(this.port) !== 80))) {\n    port = ':' + this.port;\n  }\n\n  // prepend ? to query\n  if (query.length) {\n    query = '?' + query;\n  }\n\n  var ipv6 = this.hostname.indexOf(':') !== -1;\n  return schema + '://' + (ipv6 ? '[' + this.hostname + ']' : this.hostname) + port + this.path + query;\n};\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ../~/engine.io-client/lib/transports/polling.js\n// module id = 471\n// module chunks = 1 4 8 9 11","/**\n * Module dependencies.\n */\n\nvar parser = require('engine.io-parser');\nvar Emitter = require('component-emitter');\n\n/**\n * Module exports.\n */\n\nmodule.exports = Transport;\n\n/**\n * Transport abstract constructor.\n *\n * @param {Object} options.\n * @api private\n */\n\nfunction Transport (opts) {\n  this.path = opts.path;\n  this.hostname = opts.hostname;\n  this.port = opts.port;\n  this.secure = opts.secure;\n  this.query = opts.query;\n  this.timestampParam = opts.timestampParam;\n  this.timestampRequests = opts.timestampRequests;\n  this.readyState = '';\n  this.agent = opts.agent || false;\n  this.socket = opts.socket;\n  this.enablesXDR = opts.enablesXDR;\n\n  // SSL options for Node.js client\n  this.pfx = opts.pfx;\n  this.key = opts.key;\n  this.passphrase = opts.passphrase;\n  this.cert = opts.cert;\n  this.ca = opts.ca;\n  this.ciphers = opts.ciphers;\n  this.rejectUnauthorized = opts.rejectUnauthorized;\n  this.forceNode = opts.forceNode;\n\n  // other options for Node.js client\n  this.extraHeaders = opts.extraHeaders;\n  this.localAddress = opts.localAddress;\n}\n\n/**\n * Mix in `Emitter`.\n */\n\nEmitter(Transport.prototype);\n\n/**\n * Emits an error.\n *\n * @param {String} str\n * @return {Transport} for chaining\n * @api public\n */\n\nTransport.prototype.onError = function (msg, desc) {\n  var err = new Error(msg);\n  err.type = 'TransportError';\n  err.description = desc;\n  this.emit('error', err);\n  return this;\n};\n\n/**\n * Opens the transport.\n *\n * @api public\n */\n\nTransport.prototype.open = function () {\n  if ('closed' === this.readyState || '' === this.readyState) {\n    this.readyState = 'opening';\n    this.doOpen();\n  }\n\n  return this;\n};\n\n/**\n * Closes the transport.\n *\n * @api private\n */\n\nTransport.prototype.close = function () {\n  if ('opening' === this.readyState || 'open' === this.readyState) {\n    this.doClose();\n    this.onClose();\n  }\n\n  return this;\n};\n\n/**\n * Sends multiple packets.\n *\n * @param {Array} packets\n * @api private\n */\n\nTransport.prototype.send = function (packets) {\n  if ('open' === this.readyState) {\n    this.write(packets);\n  } else {\n    throw new Error('Transport not open');\n  }\n};\n\n/**\n * Called upon open\n *\n * @api private\n */\n\nTransport.prototype.onOpen = function () {\n  this.readyState = 'open';\n  this.writable = true;\n  this.emit('open');\n};\n\n/**\n * Called with data.\n *\n * @param {String} data\n * @api private\n */\n\nTransport.prototype.onData = function (data) {\n  var packet = parser.decodePacket(data, this.socket.binaryType);\n  this.onPacket(packet);\n};\n\n/**\n * Called with a decoded packet.\n */\n\nTransport.prototype.onPacket = function (packet) {\n  this.emit('packet', packet);\n};\n\n/**\n * Called upon close.\n *\n * @api private\n */\n\nTransport.prototype.onClose = function () {\n  this.readyState = 'closed';\n  this.emit('close');\n};\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ../~/engine.io-client/lib/transport.js\n// module id = 472\n// module chunks = 1 4 8 9 11","/**\n * Module dependencies.\n */\n\nvar keys = require('./keys');\nvar hasBinary = require('has-binary');\nvar sliceBuffer = require('arraybuffer.slice');\nvar after = require('after');\nvar utf8 = require('wtf-8');\n\nvar base64encoder;\nif (global && global.ArrayBuffer) {\n  base64encoder = require('base64-arraybuffer');\n}\n\n/**\n * Check if we are running an android browser. That requires us to use\n * ArrayBuffer with polling transports...\n *\n * http://ghinda.net/jpeg-blob-ajax-android/\n */\n\nvar isAndroid = typeof navigator !== 'undefined' && /Android/i.test(navigator.userAgent);\n\n/**\n * Check if we are running in PhantomJS.\n * Uploading a Blob with PhantomJS does not work correctly, as reported here:\n * https://github.com/ariya/phantomjs/issues/11395\n * @type boolean\n */\nvar isPhantomJS = typeof navigator !== 'undefined' && /PhantomJS/i.test(navigator.userAgent);\n\n/**\n * When true, avoids using Blobs to encode payloads.\n * @type boolean\n */\nvar dontSendBlobs = isAndroid || isPhantomJS;\n\n/**\n * Current protocol version.\n */\n\nexports.protocol = 3;\n\n/**\n * Packet types.\n */\n\nvar packets = exports.packets = {\n    open:     0    // non-ws\n  , close:    1    // non-ws\n  , ping:     2\n  , pong:     3\n  , message:  4\n  , upgrade:  5\n  , noop:     6\n};\n\nvar packetslist = keys(packets);\n\n/**\n * Premade error packet.\n */\n\nvar err = { type: 'error', data: 'parser error' };\n\n/**\n * Create a blob api even for blob builder when vendor prefixes exist\n */\n\nvar Blob = require('blob');\n\n/**\n * Encodes a packet.\n *\n *     <packet type id> [ <data> ]\n *\n * Example:\n *\n *     5hello world\n *     3\n *     4\n *\n * Binary is encoded in an identical principle\n *\n * @api private\n */\n\nexports.encodePacket = function (packet, supportsBinary, utf8encode, callback) {\n  if ('function' == typeof supportsBinary) {\n    callback = supportsBinary;\n    supportsBinary = false;\n  }\n\n  if ('function' == typeof utf8encode) {\n    callback = utf8encode;\n    utf8encode = null;\n  }\n\n  var data = (packet.data === undefined)\n    ? undefined\n    : packet.data.buffer || packet.data;\n\n  if (global.ArrayBuffer && data instanceof ArrayBuffer) {\n    return encodeArrayBuffer(packet, supportsBinary, callback);\n  } else if (Blob && data instanceof global.Blob) {\n    return encodeBlob(packet, supportsBinary, callback);\n  }\n\n  // might be an object with { base64: true, data: dataAsBase64String }\n  if (data && data.base64) {\n    return encodeBase64Object(packet, callback);\n  }\n\n  // Sending data as a utf-8 string\n  var encoded = packets[packet.type];\n\n  // data fragment is optional\n  if (undefined !== packet.data) {\n    encoded += utf8encode ? utf8.encode(String(packet.data)) : String(packet.data);\n  }\n\n  return callback('' + encoded);\n\n};\n\nfunction encodeBase64Object(packet, callback) {\n  // packet data is an object { base64: true, data: dataAsBase64String }\n  var message = 'b' + exports.packets[packet.type] + packet.data.data;\n  return callback(message);\n}\n\n/**\n * Encode packet helpers for binary types\n */\n\nfunction encodeArrayBuffer(packet, supportsBinary, callback) {\n  if (!supportsBinary) {\n    return exports.encodeBase64Packet(packet, callback);\n  }\n\n  var data = packet.data;\n  var contentArray = new Uint8Array(data);\n  var resultBuffer = new Uint8Array(1 + data.byteLength);\n\n  resultBuffer[0] = packets[packet.type];\n  for (var i = 0; i < contentArray.length; i++) {\n    resultBuffer[i+1] = contentArray[i];\n  }\n\n  return callback(resultBuffer.buffer);\n}\n\nfunction encodeBlobAsArrayBuffer(packet, supportsBinary, callback) {\n  if (!supportsBinary) {\n    return exports.encodeBase64Packet(packet, callback);\n  }\n\n  var fr = new FileReader();\n  fr.onload = function() {\n    packet.data = fr.result;\n    exports.encodePacket(packet, supportsBinary, true, callback);\n  };\n  return fr.readAsArrayBuffer(packet.data);\n}\n\nfunction encodeBlob(packet, supportsBinary, callback) {\n  if (!supportsBinary) {\n    return exports.encodeBase64Packet(packet, callback);\n  }\n\n  if (dontSendBlobs) {\n    return encodeBlobAsArrayBuffer(packet, supportsBinary, callback);\n  }\n\n  var length = new Uint8Array(1);\n  length[0] = packets[packet.type];\n  var blob = new Blob([length.buffer, packet.data]);\n\n  return callback(blob);\n}\n\n/**\n * Encodes a packet with binary data in a base64 string\n *\n * @param {Object} packet, has `type` and `data`\n * @return {String} base64 encoded message\n */\n\nexports.encodeBase64Packet = function(packet, callback) {\n  var message = 'b' + exports.packets[packet.type];\n  if (Blob && packet.data instanceof global.Blob) {\n    var fr = new FileReader();\n    fr.onload = function() {\n      var b64 = fr.result.split(',')[1];\n      callback(message + b64);\n    };\n    return fr.readAsDataURL(packet.data);\n  }\n\n  var b64data;\n  try {\n    b64data = String.fromCharCode.apply(null, new Uint8Array(packet.data));\n  } catch (e) {\n    // iPhone Safari doesn't let you apply with typed arrays\n    var typed = new Uint8Array(packet.data);\n    var basic = new Array(typed.length);\n    for (var i = 0; i < typed.length; i++) {\n      basic[i] = typed[i];\n    }\n    b64data = String.fromCharCode.apply(null, basic);\n  }\n  message += global.btoa(b64data);\n  return callback(message);\n};\n\n/**\n * Decodes a packet. Changes format to Blob if requested.\n *\n * @return {Object} with `type` and `data` (if any)\n * @api private\n */\n\nexports.decodePacket = function (data, binaryType, utf8decode) {\n  if (data === undefined) {\n    return err;\n  }\n  // String data\n  if (typeof data == 'string') {\n    if (data.charAt(0) == 'b') {\n      return exports.decodeBase64Packet(data.substr(1), binaryType);\n    }\n\n    if (utf8decode) {\n      data = tryDecode(data);\n      if (data === false) {\n        return err;\n      }\n    }\n    var type = data.charAt(0);\n\n    if (Number(type) != type || !packetslist[type]) {\n      return err;\n    }\n\n    if (data.length > 1) {\n      return { type: packetslist[type], data: data.substring(1) };\n    } else {\n      return { type: packetslist[type] };\n    }\n  }\n\n  var asArray = new Uint8Array(data);\n  var type = asArray[0];\n  var rest = sliceBuffer(data, 1);\n  if (Blob && binaryType === 'blob') {\n    rest = new Blob([rest]);\n  }\n  return { type: packetslist[type], data: rest };\n};\n\nfunction tryDecode(data) {\n  try {\n    data = utf8.decode(data);\n  } catch (e) {\n    return false;\n  }\n  return data;\n}\n\n/**\n * Decodes a packet encoded in a base64 string\n *\n * @param {String} base64 encoded message\n * @return {Object} with `type` and `data` (if any)\n */\n\nexports.decodeBase64Packet = function(msg, binaryType) {\n  var type = packetslist[msg.charAt(0)];\n  if (!base64encoder) {\n    return { type: type, data: { base64: true, data: msg.substr(1) } };\n  }\n\n  var data = base64encoder.decode(msg.substr(1));\n\n  if (binaryType === 'blob' && Blob) {\n    data = new Blob([data]);\n  }\n\n  return { type: type, data: data };\n};\n\n/**\n * Encodes multiple messages (payload).\n *\n *     <length>:data\n *\n * Example:\n *\n *     11:hello world2:hi\n *\n * If any contents are binary, they will be encoded as base64 strings. Base64\n * encoded strings are marked with a b before the length specifier\n *\n * @param {Array} packets\n * @api private\n */\n\nexports.encodePayload = function (packets, supportsBinary, callback) {\n  if (typeof supportsBinary == 'function') {\n    callback = supportsBinary;\n    supportsBinary = null;\n  }\n\n  var isBinary = hasBinary(packets);\n\n  if (supportsBinary && isBinary) {\n    if (Blob && !dontSendBlobs) {\n      return exports.encodePayloadAsBlob(packets, callback);\n    }\n\n    return exports.encodePayloadAsArrayBuffer(packets, callback);\n  }\n\n  if (!packets.length) {\n    return callback('0:');\n  }\n\n  function setLengthHeader(message) {\n    return message.length + ':' + message;\n  }\n\n  function encodeOne(packet, doneCallback) {\n    exports.encodePacket(packet, !isBinary ? false : supportsBinary, true, function(message) {\n      doneCallback(null, setLengthHeader(message));\n    });\n  }\n\n  map(packets, encodeOne, function(err, results) {\n    return callback(results.join(''));\n  });\n};\n\n/**\n * Async array map using after\n */\n\nfunction map(ary, each, done) {\n  var result = new Array(ary.length);\n  var next = after(ary.length, done);\n\n  var eachWithIndex = function(i, el, cb) {\n    each(el, function(error, msg) {\n      result[i] = msg;\n      cb(error, result);\n    });\n  };\n\n  for (var i = 0; i < ary.length; i++) {\n    eachWithIndex(i, ary[i], next);\n  }\n}\n\n/*\n * Decodes data when a payload is maybe expected. Possible binary contents are\n * decoded from their base64 representation\n *\n * @param {String} data, callback method\n * @api public\n */\n\nexports.decodePayload = function (data, binaryType, callback) {\n  if (typeof data != 'string') {\n    return exports.decodePayloadAsBinary(data, binaryType, callback);\n  }\n\n  if (typeof binaryType === 'function') {\n    callback = binaryType;\n    binaryType = null;\n  }\n\n  var packet;\n  if (data == '') {\n    // parser error - ignoring payload\n    return callback(err, 0, 1);\n  }\n\n  var length = ''\n    , n, msg;\n\n  for (var i = 0, l = data.length; i < l; i++) {\n    var chr = data.charAt(i);\n\n    if (':' != chr) {\n      length += chr;\n    } else {\n      if ('' == length || (length != (n = Number(length)))) {\n        // parser error - ignoring payload\n        return callback(err, 0, 1);\n      }\n\n      msg = data.substr(i + 1, n);\n\n      if (length != msg.length) {\n        // parser error - ignoring payload\n        return callback(err, 0, 1);\n      }\n\n      if (msg.length) {\n        packet = exports.decodePacket(msg, binaryType, true);\n\n        if (err.type == packet.type && err.data == packet.data) {\n          // parser error in individual packet - ignoring payload\n          return callback(err, 0, 1);\n        }\n\n        var ret = callback(packet, i + n, l);\n        if (false === ret) return;\n      }\n\n      // advance cursor\n      i += n;\n      length = '';\n    }\n  }\n\n  if (length != '') {\n    // parser error - ignoring payload\n    return callback(err, 0, 1);\n  }\n\n};\n\n/**\n * Encodes multiple messages (payload) as binary.\n *\n * <1 = binary, 0 = string><number from 0-9><number from 0-9>[...]<number\n * 255><data>\n *\n * Example:\n * 1 3 255 1 2 3, if the binary contents are interpreted as 8 bit integers\n *\n * @param {Array} packets\n * @return {ArrayBuffer} encoded payload\n * @api private\n */\n\nexports.encodePayloadAsArrayBuffer = function(packets, callback) {\n  if (!packets.length) {\n    return callback(new ArrayBuffer(0));\n  }\n\n  function encodeOne(packet, doneCallback) {\n    exports.encodePacket(packet, true, true, function(data) {\n      return doneCallback(null, data);\n    });\n  }\n\n  map(packets, encodeOne, function(err, encodedPackets) {\n    var totalLength = encodedPackets.reduce(function(acc, p) {\n      var len;\n      if (typeof p === 'string'){\n        len = p.length;\n      } else {\n        len = p.byteLength;\n      }\n      return acc + len.toString().length + len + 2; // string/binary identifier + separator = 2\n    }, 0);\n\n    var resultArray = new Uint8Array(totalLength);\n\n    var bufferIndex = 0;\n    encodedPackets.forEach(function(p) {\n      var isString = typeof p === 'string';\n      var ab = p;\n      if (isString) {\n        var view = new Uint8Array(p.length);\n        for (var i = 0; i < p.length; i++) {\n          view[i] = p.charCodeAt(i);\n        }\n        ab = view.buffer;\n      }\n\n      if (isString) { // not true binary\n        resultArray[bufferIndex++] = 0;\n      } else { // true binary\n        resultArray[bufferIndex++] = 1;\n      }\n\n      var lenStr = ab.byteLength.toString();\n      for (var i = 0; i < lenStr.length; i++) {\n        resultArray[bufferIndex++] = parseInt(lenStr[i]);\n      }\n      resultArray[bufferIndex++] = 255;\n\n      var view = new Uint8Array(ab);\n      for (var i = 0; i < view.length; i++) {\n        resultArray[bufferIndex++] = view[i];\n      }\n    });\n\n    return callback(resultArray.buffer);\n  });\n};\n\n/**\n * Encode as Blob\n */\n\nexports.encodePayloadAsBlob = function(packets, callback) {\n  function encodeOne(packet, doneCallback) {\n    exports.encodePacket(packet, true, true, function(encoded) {\n      var binaryIdentifier = new Uint8Array(1);\n      binaryIdentifier[0] = 1;\n      if (typeof encoded === 'string') {\n        var view = new Uint8Array(encoded.length);\n        for (var i = 0; i < encoded.length; i++) {\n          view[i] = encoded.charCodeAt(i);\n        }\n        encoded = view.buffer;\n        binaryIdentifier[0] = 0;\n      }\n\n      var len = (encoded instanceof ArrayBuffer)\n        ? encoded.byteLength\n        : encoded.size;\n\n      var lenStr = len.toString();\n      var lengthAry = new Uint8Array(lenStr.length + 1);\n      for (var i = 0; i < lenStr.length; i++) {\n        lengthAry[i] = parseInt(lenStr[i]);\n      }\n      lengthAry[lenStr.length] = 255;\n\n      if (Blob) {\n        var blob = new Blob([binaryIdentifier.buffer, lengthAry.buffer, encoded]);\n        doneCallback(null, blob);\n      }\n    });\n  }\n\n  map(packets, encodeOne, function(err, results) {\n    return callback(new Blob(results));\n  });\n};\n\n/*\n * Decodes data when a payload is maybe expected. Strings are decoded by\n * interpreting each byte as a key code for entries marked to start with 0. See\n * description of encodePayloadAsBinary\n *\n * @param {ArrayBuffer} data, callback method\n * @api public\n */\n\nexports.decodePayloadAsBinary = function (data, binaryType, callback) {\n  if (typeof binaryType === 'function') {\n    callback = binaryType;\n    binaryType = null;\n  }\n\n  var bufferTail = data;\n  var buffers = [];\n\n  var numberTooLong = false;\n  while (bufferTail.byteLength > 0) {\n    var tailArray = new Uint8Array(bufferTail);\n    var isString = tailArray[0] === 0;\n    var msgLength = '';\n\n    for (var i = 1; ; i++) {\n      if (tailArray[i] == 255) break;\n\n      if (msgLength.length > 310) {\n        numberTooLong = true;\n        break;\n      }\n\n      msgLength += tailArray[i];\n    }\n\n    if(numberTooLong) return callback(err, 0, 1);\n\n    bufferTail = sliceBuffer(bufferTail, 2 + msgLength.length);\n    msgLength = parseInt(msgLength);\n\n    var msg = sliceBuffer(bufferTail, 0, msgLength);\n    if (isString) {\n      try {\n        msg = String.fromCharCode.apply(null, new Uint8Array(msg));\n      } catch (e) {\n        // iPhone Safari doesn't let you apply to typed arrays\n        var typed = new Uint8Array(msg);\n        msg = '';\n        for (var i = 0; i < typed.length; i++) {\n          msg += String.fromCharCode(typed[i]);\n        }\n      }\n    }\n\n    buffers.push(msg);\n    bufferTail = sliceBuffer(bufferTail, msgLength);\n  }\n\n  var total = buffers.length;\n  buffers.forEach(function(buffer, i) {\n    callback(exports.decodePacket(buffer, binaryType, true), i, total);\n  });\n};\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ../~/engine.io-parser/lib/browser.js\n// module id = 473\n// module chunks = 1 4 8 9 11","\n/**\n * Gets the keys for an object.\n *\n * @return {Array} keys\n * @api private\n */\n\nmodule.exports = Object.keys || function keys (obj){\n  var arr = [];\n  var has = Object.prototype.hasOwnProperty;\n\n  for (var i in obj) {\n    if (has.call(obj, i)) {\n      arr.push(i);\n    }\n  }\n  return arr;\n};\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ../~/engine.io-parser/lib/keys.js\n// module id = 474\n// module chunks = 1 4 8 9 11","\n/*\n * Module requirements.\n */\n\nvar isArray = require('isarray');\n\n/**\n * Module exports.\n */\n\nmodule.exports = hasBinary;\n\n/**\n * Checks for binary data.\n *\n * Right now only Buffer and ArrayBuffer are supported..\n *\n * @param {Object} anything\n * @api public\n */\n\nfunction hasBinary(data) {\n\n  function _hasBinary(obj) {\n    if (!obj) return false;\n\n    if ( (global.Buffer && global.Buffer.isBuffer && global.Buffer.isBuffer(obj)) ||\n         (global.ArrayBuffer && obj instanceof ArrayBuffer) ||\n         (global.Blob && obj instanceof Blob) ||\n         (global.File && obj instanceof File)\n        ) {\n      return true;\n    }\n\n    if (isArray(obj)) {\n      for (var i = 0; i < obj.length; i++) {\n          if (_hasBinary(obj[i])) {\n              return true;\n          }\n      }\n    } else if (obj && 'object' == typeof obj) {\n      // see: https://github.com/Automattic/has-binary/pull/4\n      if (obj.toJSON && 'function' == typeof obj.toJSON) {\n        obj = obj.toJSON();\n      }\n\n      for (var key in obj) {\n        if (Object.prototype.hasOwnProperty.call(obj, key) && _hasBinary(obj[key])) {\n          return true;\n        }\n      }\n    }\n\n    return false;\n  }\n\n  return _hasBinary(data);\n}\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ../~/has-binary/index.js\n// module id = 475\n// module chunks = 1 4 8 9 11","/**\n * An abstraction for slicing an arraybuffer even when\n * ArrayBuffer.prototype.slice is not supported\n *\n * @api public\n */\n\nmodule.exports = function(arraybuffer, start, end) {\n  var bytes = arraybuffer.byteLength;\n  start = start || 0;\n  end = end || bytes;\n\n  if (arraybuffer.slice) { return arraybuffer.slice(start, end); }\n\n  if (start < 0) { start += bytes; }\n  if (end < 0) { end += bytes; }\n  if (end > bytes) { end = bytes; }\n\n  if (start >= bytes || start >= end || bytes === 0) {\n    return new ArrayBuffer(0);\n  }\n\n  var abv = new Uint8Array(arraybuffer);\n  var result = new Uint8Array(end - start);\n  for (var i = start, ii = 0; i < end; i++, ii++) {\n    result[ii] = abv[i];\n  }\n  return result.buffer;\n};\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ../~/arraybuffer.slice/index.js\n// module id = 477\n// module chunks = 1 4 8 9 11","module.exports = after\n\nfunction after(count, callback, err_cb) {\n    var bail = false\n    err_cb = err_cb || noop\n    proxy.count = count\n\n    return (count === 0) ? callback() : proxy\n\n    function proxy(err, result) {\n        if (proxy.count <= 0) {\n            throw new Error('after called too many times')\n        }\n        --proxy.count\n\n        // after first error, rest are passed to err_cb\n        if (err) {\n            bail = true\n            callback(err)\n            // future error callbacks will go to error handler\n            callback = err_cb\n        } else if (proxy.count === 0 && !bail) {\n            callback(null, result)\n        }\n    }\n}\n\nfunction noop() {}\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ../~/after/index.js\n// module id = 478\n// module chunks = 1 4 8 9 11","/*! https://mths.be/wtf8 v1.0.0 by @mathias */\n;(function(root) {\n\n\t// Detect free variables `exports`\n\tvar freeExports = typeof exports == 'object' && exports;\n\n\t// Detect free variable `module`\n\tvar freeModule = typeof module == 'object' && module &&\n\t\tmodule.exports == freeExports && module;\n\n\t// Detect free variable `global`, from Node.js or Browserified code,\n\t// and use it as `root`\n\tvar freeGlobal = typeof global == 'object' && global;\n\tif (freeGlobal.global === freeGlobal || freeGlobal.window === freeGlobal) {\n\t\troot = freeGlobal;\n\t}\n\n\t/*--------------------------------------------------------------------------*/\n\n\tvar stringFromCharCode = String.fromCharCode;\n\n\t// Taken from https://mths.be/punycode\n\tfunction ucs2decode(string) {\n\t\tvar output = [];\n\t\tvar counter = 0;\n\t\tvar length = string.length;\n\t\tvar value;\n\t\tvar extra;\n\t\twhile (counter < length) {\n\t\t\tvalue = string.charCodeAt(counter++);\n\t\t\tif (value >= 0xD800 && value <= 0xDBFF && counter < length) {\n\t\t\t\t// high surrogate, and there is a next character\n\t\t\t\textra = string.charCodeAt(counter++);\n\t\t\t\tif ((extra & 0xFC00) == 0xDC00) { // low surrogate\n\t\t\t\t\toutput.push(((value & 0x3FF) << 10) + (extra & 0x3FF) + 0x10000);\n\t\t\t\t} else {\n\t\t\t\t\t// unmatched surrogate; only append this code unit, in case the next\n\t\t\t\t\t// code unit is the high surrogate of a surrogate pair\n\t\t\t\t\toutput.push(value);\n\t\t\t\t\tcounter--;\n\t\t\t\t}\n\t\t\t} else {\n\t\t\t\toutput.push(value);\n\t\t\t}\n\t\t}\n\t\treturn output;\n\t}\n\n\t// Taken from https://mths.be/punycode\n\tfunction ucs2encode(array) {\n\t\tvar length = array.length;\n\t\tvar index = -1;\n\t\tvar value;\n\t\tvar output = '';\n\t\twhile (++index < length) {\n\t\t\tvalue = array[index];\n\t\t\tif (value > 0xFFFF) {\n\t\t\t\tvalue -= 0x10000;\n\t\t\t\toutput += stringFromCharCode(value >>> 10 & 0x3FF | 0xD800);\n\t\t\t\tvalue = 0xDC00 | value & 0x3FF;\n\t\t\t}\n\t\t\toutput += stringFromCharCode(value);\n\t\t}\n\t\treturn output;\n\t}\n\n\t/*--------------------------------------------------------------------------*/\n\n\tfunction createByte(codePoint, shift) {\n\t\treturn stringFromCharCode(((codePoint >> shift) & 0x3F) | 0x80);\n\t}\n\n\tfunction encodeCodePoint(codePoint) {\n\t\tif ((codePoint & 0xFFFFFF80) == 0) { // 1-byte sequence\n\t\t\treturn stringFromCharCode(codePoint);\n\t\t}\n\t\tvar symbol = '';\n\t\tif ((codePoint & 0xFFFFF800) == 0) { // 2-byte sequence\n\t\t\tsymbol = stringFromCharCode(((codePoint >> 6) & 0x1F) | 0xC0);\n\t\t}\n\t\telse if ((codePoint & 0xFFFF0000) == 0) { // 3-byte sequence\n\t\t\tsymbol = stringFromCharCode(((codePoint >> 12) & 0x0F) | 0xE0);\n\t\t\tsymbol += createByte(codePoint, 6);\n\t\t}\n\t\telse if ((codePoint & 0xFFE00000) == 0) { // 4-byte sequence\n\t\t\tsymbol = stringFromCharCode(((codePoint >> 18) & 0x07) | 0xF0);\n\t\t\tsymbol += createByte(codePoint, 12);\n\t\t\tsymbol += createByte(codePoint, 6);\n\t\t}\n\t\tsymbol += stringFromCharCode((codePoint & 0x3F) | 0x80);\n\t\treturn symbol;\n\t}\n\n\tfunction wtf8encode(string) {\n\t\tvar codePoints = ucs2decode(string);\n\t\tvar length = codePoints.length;\n\t\tvar index = -1;\n\t\tvar codePoint;\n\t\tvar byteString = '';\n\t\twhile (++index < length) {\n\t\t\tcodePoint = codePoints[index];\n\t\t\tbyteString += encodeCodePoint(codePoint);\n\t\t}\n\t\treturn byteString;\n\t}\n\n\t/*--------------------------------------------------------------------------*/\n\n\tfunction readContinuationByte() {\n\t\tif (byteIndex >= byteCount) {\n\t\t\tthrow Error('Invalid byte index');\n\t\t}\n\n\t\tvar continuationByte = byteArray[byteIndex] & 0xFF;\n\t\tbyteIndex++;\n\n\t\tif ((continuationByte & 0xC0) == 0x80) {\n\t\t\treturn continuationByte & 0x3F;\n\t\t}\n\n\t\t// If we end up here, it’s not a continuation byte.\n\t\tthrow Error('Invalid continuation byte');\n\t}\n\n\tfunction decodeSymbol() {\n\t\tvar byte1;\n\t\tvar byte2;\n\t\tvar byte3;\n\t\tvar byte4;\n\t\tvar codePoint;\n\n\t\tif (byteIndex > byteCount) {\n\t\t\tthrow Error('Invalid byte index');\n\t\t}\n\n\t\tif (byteIndex == byteCount) {\n\t\t\treturn false;\n\t\t}\n\n\t\t// Read the first byte.\n\t\tbyte1 = byteArray[byteIndex] & 0xFF;\n\t\tbyteIndex++;\n\n\t\t// 1-byte sequence (no continuation bytes)\n\t\tif ((byte1 & 0x80) == 0) {\n\t\t\treturn byte1;\n\t\t}\n\n\t\t// 2-byte sequence\n\t\tif ((byte1 & 0xE0) == 0xC0) {\n\t\t\tvar byte2 = readContinuationByte();\n\t\t\tcodePoint = ((byte1 & 0x1F) << 6) | byte2;\n\t\t\tif (codePoint >= 0x80) {\n\t\t\t\treturn codePoint;\n\t\t\t} else {\n\t\t\t\tthrow Error('Invalid continuation byte');\n\t\t\t}\n\t\t}\n\n\t\t// 3-byte sequence (may include unpaired surrogates)\n\t\tif ((byte1 & 0xF0) == 0xE0) {\n\t\t\tbyte2 = readContinuationByte();\n\t\t\tbyte3 = readContinuationByte();\n\t\t\tcodePoint = ((byte1 & 0x0F) << 12) | (byte2 << 6) | byte3;\n\t\t\tif (codePoint >= 0x0800) {\n\t\t\t\treturn codePoint;\n\t\t\t} else {\n\t\t\t\tthrow Error('Invalid continuation byte');\n\t\t\t}\n\t\t}\n\n\t\t// 4-byte sequence\n\t\tif ((byte1 & 0xF8) == 0xF0) {\n\t\t\tbyte2 = readContinuationByte();\n\t\t\tbyte3 = readContinuationByte();\n\t\t\tbyte4 = readContinuationByte();\n\t\t\tcodePoint = ((byte1 & 0x0F) << 0x12) | (byte2 << 0x0C) |\n\t\t\t\t(byte3 << 0x06) | byte4;\n\t\t\tif (codePoint >= 0x010000 && codePoint <= 0x10FFFF) {\n\t\t\t\treturn codePoint;\n\t\t\t}\n\t\t}\n\n\t\tthrow Error('Invalid WTF-8 detected');\n\t}\n\n\tvar byteArray;\n\tvar byteCount;\n\tvar byteIndex;\n\tfunction wtf8decode(byteString) {\n\t\tbyteArray = ucs2decode(byteString);\n\t\tbyteCount = byteArray.length;\n\t\tbyteIndex = 0;\n\t\tvar codePoints = [];\n\t\tvar tmp;\n\t\twhile ((tmp = decodeSymbol()) !== false) {\n\t\t\tcodePoints.push(tmp);\n\t\t}\n\t\treturn ucs2encode(codePoints);\n\t}\n\n\t/*--------------------------------------------------------------------------*/\n\n\tvar wtf8 = {\n\t\t'version': '1.0.0',\n\t\t'encode': wtf8encode,\n\t\t'decode': wtf8decode\n\t};\n\n\t// Some AMD build optimizers, like r.js, check for specific condition patterns\n\t// like the following:\n\tif (\n\t\ttypeof define == 'function' &&\n\t\ttypeof define.amd == 'object' &&\n\t\tdefine.amd\n\t) {\n\t\tdefine(function() {\n\t\t\treturn wtf8;\n\t\t});\n\t}\telse if (freeExports && !freeExports.nodeType) {\n\t\tif (freeModule) { // in Node.js or RingoJS v0.8.0+\n\t\t\tfreeModule.exports = wtf8;\n\t\t} else { // in Narwhal or RingoJS v0.7.0-\n\t\t\tvar object = {};\n\t\t\tvar hasOwnProperty = object.hasOwnProperty;\n\t\t\tfor (var key in wtf8) {\n\t\t\t\thasOwnProperty.call(wtf8, key) && (freeExports[key] = wtf8[key]);\n\t\t\t}\n\t\t}\n\t} else { // in Rhino or a web browser\n\t\troot.wtf8 = wtf8;\n\t}\n\n}(this));\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ../~/wtf-8/wtf-8.js\n// module id = 479\n// module chunks = 1 4 8 9 11","/*\n * base64-arraybuffer\n * https://github.com/niklasvh/base64-arraybuffer\n *\n * Copyright (c) 2012 Niklas von Hertzen\n * Licensed under the MIT license.\n */\n(function(){\n  \"use strict\";\n\n  var chars = \"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/\";\n\n  // Use a lookup table to find the index.\n  var lookup = new Uint8Array(256);\n  for (var i = 0; i < chars.length; i++) {\n    lookup[chars.charCodeAt(i)] = i;\n  }\n\n  exports.encode = function(arraybuffer) {\n    var bytes = new Uint8Array(arraybuffer),\n    i, len = bytes.length, base64 = \"\";\n\n    for (i = 0; i < len; i+=3) {\n      base64 += chars[bytes[i] >> 2];\n      base64 += chars[((bytes[i] & 3) << 4) | (bytes[i + 1] >> 4)];\n      base64 += chars[((bytes[i + 1] & 15) << 2) | (bytes[i + 2] >> 6)];\n      base64 += chars[bytes[i + 2] & 63];\n    }\n\n    if ((len % 3) === 2) {\n      base64 = base64.substring(0, base64.length - 1) + \"=\";\n    } else if (len % 3 === 1) {\n      base64 = base64.substring(0, base64.length - 2) + \"==\";\n    }\n\n    return base64;\n  };\n\n  exports.decode =  function(base64) {\n    var bufferLength = base64.length * 0.75,\n    len = base64.length, i, p = 0,\n    encoded1, encoded2, encoded3, encoded4;\n\n    if (base64[base64.length - 1] === \"=\") {\n      bufferLength--;\n      if (base64[base64.length - 2] === \"=\") {\n        bufferLength--;\n      }\n    }\n\n    var arraybuffer = new ArrayBuffer(bufferLength),\n    bytes = new Uint8Array(arraybuffer);\n\n    for (i = 0; i < len; i+=4) {\n      encoded1 = lookup[base64.charCodeAt(i)];\n      encoded2 = lookup[base64.charCodeAt(i+1)];\n      encoded3 = lookup[base64.charCodeAt(i+2)];\n      encoded4 = lookup[base64.charCodeAt(i+3)];\n\n      bytes[p++] = (encoded1 << 2) | (encoded2 >> 4);\n      bytes[p++] = ((encoded2 & 15) << 4) | (encoded3 >> 2);\n      bytes[p++] = ((encoded3 & 3) << 6) | (encoded4 & 63);\n    }\n\n    return arraybuffer;\n  };\n})();\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ../~/base64-arraybuffer/lib/base64-arraybuffer.js\n// module id = 480\n// module chunks = 1 4 8 9 11","/**\n * Create a blob builder even when vendor prefixes exist\n */\n\nvar BlobBuilder = global.BlobBuilder\n  || global.WebKitBlobBuilder\n  || global.MSBlobBuilder\n  || global.MozBlobBuilder;\n\n/**\n * Check if Blob constructor is supported\n */\n\nvar blobSupported = (function() {\n  try {\n    var a = new Blob(['hi']);\n    return a.size === 2;\n  } catch(e) {\n    return false;\n  }\n})();\n\n/**\n * Check if Blob constructor supports ArrayBufferViews\n * Fails in Safari 6, so we need to map to ArrayBuffers there.\n */\n\nvar blobSupportsArrayBufferView = blobSupported && (function() {\n  try {\n    var b = new Blob([new Uint8Array([1,2])]);\n    return b.size === 2;\n  } catch(e) {\n    return false;\n  }\n})();\n\n/**\n * Check if BlobBuilder is supported\n */\n\nvar blobBuilderSupported = BlobBuilder\n  && BlobBuilder.prototype.append\n  && BlobBuilder.prototype.getBlob;\n\n/**\n * Helper function that maps ArrayBufferViews to ArrayBuffers\n * Used by BlobBuilder constructor and old browsers that didn't\n * support it in the Blob constructor.\n */\n\nfunction mapArrayBufferViews(ary) {\n  for (var i = 0; i < ary.length; i++) {\n    var chunk = ary[i];\n    if (chunk.buffer instanceof ArrayBuffer) {\n      var buf = chunk.buffer;\n\n      // if this is a subarray, make a copy so we only\n      // include the subarray region from the underlying buffer\n      if (chunk.byteLength !== buf.byteLength) {\n        var copy = new Uint8Array(chunk.byteLength);\n        copy.set(new Uint8Array(buf, chunk.byteOffset, chunk.byteLength));\n        buf = copy.buffer;\n      }\n\n      ary[i] = buf;\n    }\n  }\n}\n\nfunction BlobBuilderConstructor(ary, options) {\n  options = options || {};\n\n  var bb = new BlobBuilder();\n  mapArrayBufferViews(ary);\n\n  for (var i = 0; i < ary.length; i++) {\n    bb.append(ary[i]);\n  }\n\n  return (options.type) ? bb.getBlob(options.type) : bb.getBlob();\n};\n\nfunction BlobConstructor(ary, options) {\n  mapArrayBufferViews(ary);\n  return new Blob(ary, options || {});\n};\n\nmodule.exports = (function() {\n  if (blobSupported) {\n    return blobSupportsArrayBufferView ? global.Blob : BlobConstructor;\n  } else if (blobBuilderSupported) {\n    return BlobBuilderConstructor;\n  } else {\n    return undefined;\n  }\n})();\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ../~/blob/index.js\n// module id = 481\n// module chunks = 1 4 8 9 11","\r\n/**\r\n * Expose `Emitter`.\r\n */\r\n\r\nif (typeof module !== 'undefined') {\r\n  module.exports = Emitter;\r\n}\r\n\r\n/**\r\n * Initialize a new `Emitter`.\r\n *\r\n * @api public\r\n */\r\n\r\nfunction Emitter(obj) {\r\n  if (obj) return mixin(obj);\r\n};\r\n\r\n/**\r\n * Mixin the emitter properties.\r\n *\r\n * @param {Object} obj\r\n * @return {Object}\r\n * @api private\r\n */\r\n\r\nfunction mixin(obj) {\r\n  for (var key in Emitter.prototype) {\r\n    obj[key] = Emitter.prototype[key];\r\n  }\r\n  return obj;\r\n}\r\n\r\n/**\r\n * Listen on the given `event` with `fn`.\r\n *\r\n * @param {String} event\r\n * @param {Function} fn\r\n * @return {Emitter}\r\n * @api public\r\n */\r\n\r\nEmitter.prototype.on =\r\nEmitter.prototype.addEventListener = function(event, fn){\r\n  this._callbacks = this._callbacks || {};\r\n  (this._callbacks['$' + event] = this._callbacks['$' + event] || [])\r\n    .push(fn);\r\n  return this;\r\n};\r\n\r\n/**\r\n * Adds an `event` listener that will be invoked a single\r\n * time then automatically removed.\r\n *\r\n * @param {String} event\r\n * @param {Function} fn\r\n * @return {Emitter}\r\n * @api public\r\n */\r\n\r\nEmitter.prototype.once = function(event, fn){\r\n  function on() {\r\n    this.off(event, on);\r\n    fn.apply(this, arguments);\r\n  }\r\n\r\n  on.fn = fn;\r\n  this.on(event, on);\r\n  return this;\r\n};\r\n\r\n/**\r\n * Remove the given callback for `event` or all\r\n * registered callbacks.\r\n *\r\n * @param {String} event\r\n * @param {Function} fn\r\n * @return {Emitter}\r\n * @api public\r\n */\r\n\r\nEmitter.prototype.off =\r\nEmitter.prototype.removeListener =\r\nEmitter.prototype.removeAllListeners =\r\nEmitter.prototype.removeEventListener = function(event, fn){\r\n  this._callbacks = this._callbacks || {};\r\n\r\n  // all\r\n  if (0 == arguments.length) {\r\n    this._callbacks = {};\r\n    return this;\r\n  }\r\n\r\n  // specific event\r\n  var callbacks = this._callbacks['$' + event];\r\n  if (!callbacks) return this;\r\n\r\n  // remove all handlers\r\n  if (1 == arguments.length) {\r\n    delete this._callbacks['$' + event];\r\n    return this;\r\n  }\r\n\r\n  // remove specific handler\r\n  var cb;\r\n  for (var i = 0; i < callbacks.length; i++) {\r\n    cb = callbacks[i];\r\n    if (cb === fn || cb.fn === fn) {\r\n      callbacks.splice(i, 1);\r\n      break;\r\n    }\r\n  }\r\n  return this;\r\n};\r\n\r\n/**\r\n * Emit `event` with the given args.\r\n *\r\n * @param {String} event\r\n * @param {Mixed} ...\r\n * @return {Emitter}\r\n */\r\n\r\nEmitter.prototype.emit = function(event){\r\n  this._callbacks = this._callbacks || {};\r\n  var args = [].slice.call(arguments, 1)\r\n    , callbacks = this._callbacks['$' + event];\r\n\r\n  if (callbacks) {\r\n    callbacks = callbacks.slice(0);\r\n    for (var i = 0, len = callbacks.length; i < len; ++i) {\r\n      callbacks[i].apply(this, args);\r\n    }\r\n  }\r\n\r\n  return this;\r\n};\r\n\r\n/**\r\n * Return array of callbacks for `event`.\r\n *\r\n * @param {String} event\r\n * @return {Array}\r\n * @api public\r\n */\r\n\r\nEmitter.prototype.listeners = function(event){\r\n  this._callbacks = this._callbacks || {};\r\n  return this._callbacks['$' + event] || [];\r\n};\r\n\r\n/**\r\n * Check if this emitter has `event` handlers.\r\n *\r\n * @param {String} event\r\n * @return {Boolean}\r\n * @api public\r\n */\r\n\r\nEmitter.prototype.hasListeners = function(event){\r\n  return !! this.listeners(event).length;\r\n};\r\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ../~/engine.io-client/~/component-emitter/index.js\n// module id = 482\n// module chunks = 1 4 8 9 11","/**\r\n * Compiles a querystring\r\n * Returns string representation of the object\r\n *\r\n * @param {Object}\r\n * @api private\r\n */\r\n\r\nexports.encode = function (obj) {\r\n  var str = '';\r\n\r\n  for (var i in obj) {\r\n    if (obj.hasOwnProperty(i)) {\r\n      if (str.length) str += '&';\r\n      str += encodeURIComponent(i) + '=' + encodeURIComponent(obj[i]);\r\n    }\r\n  }\r\n\r\n  return str;\r\n};\r\n\r\n/**\r\n * Parses a simple querystring into an object\r\n *\r\n * @param {String} qs\r\n * @api private\r\n */\r\n\r\nexports.decode = function(qs){\r\n  var qry = {};\r\n  var pairs = qs.split('&');\r\n  for (var i = 0, l = pairs.length; i < l; i++) {\r\n    var pair = pairs[i].split('=');\r\n    qry[decodeURIComponent(pair[0])] = decodeURIComponent(pair[1]);\r\n  }\r\n  return qry;\r\n};\r\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ../~/parseqs/index.js\n// module id = 483\n// module chunks = 1 4 8 9 11","\nmodule.exports = function(a, b){\n  var fn = function(){};\n  fn.prototype = b.prototype;\n  a.prototype = new fn;\n  a.prototype.constructor = a;\n};\n\n\n//////////////////\n// WEBPACK FOOTER\n// ../~/component-inherit/index.js\n// module id = 484\n// module chunks = 1 4 8 9 11","'use strict';\n\nvar alphabet = '0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz-_'.split('')\n  , length = 64\n  , map = {}\n  , seed = 0\n  , i = 0\n  , prev;\n\n/**\n * Return a string representing the specified number.\n *\n * @param {Number} num The number to convert.\n * @returns {String} The string representation of the number.\n * @api public\n */\nfunction encode(num) {\n  var encoded = '';\n\n  do {\n    encoded = alphabet[num % length] + encoded;\n    num = Math.floor(num / length);\n  } while (num > 0);\n\n  return encoded;\n}\n\n/**\n * Return the integer value specified by the given string.\n *\n * @param {String} str The string to convert.\n * @returns {Number} The integer value represented by the string.\n * @api public\n */\nfunction decode(str) {\n  var decoded = 0;\n\n  for (i = 0; i < str.length; i++) {\n    decoded = decoded * length + map[str.charAt(i)];\n  }\n\n  return decoded;\n}\n\n/**\n * Yeast: A tiny growing id generator.\n *\n * @returns {String} A unique id.\n * @api public\n */\nfunction yeast() {\n  var now = encode(+new Date());\n\n  if (now !== prev) return seed = 0, prev = now;\n  return now +'.'+ encode(seed++);\n}\n\n//\n// Map each character to its index.\n//\nfor (; i < length; i++) map[alphabet[i]] = i;\n\n//\n// Expose the `yeast`, `encode` and `decode` functions.\n//\nyeast.encode = encode;\nyeast.decode = decode;\nmodule.exports = yeast;\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ../~/yeast/index.js\n// module id = 485\n// module chunks = 1 4 8 9 11","\n/**\n * Module requirements.\n */\n\nvar Polling = require('./polling');\nvar inherit = require('component-inherit');\n\n/**\n * Module exports.\n */\n\nmodule.exports = JSONPPolling;\n\n/**\n * Cached regular expressions.\n */\n\nvar rNewline = /\\n/g;\nvar rEscapedNewline = /\\\\n/g;\n\n/**\n * Global JSONP callbacks.\n */\n\nvar callbacks;\n\n/**\n * Noop.\n */\n\nfunction empty () { }\n\n/**\n * JSONP Polling constructor.\n *\n * @param {Object} opts.\n * @api public\n */\n\nfunction JSONPPolling (opts) {\n  Polling.call(this, opts);\n\n  this.query = this.query || {};\n\n  // define global callbacks array if not present\n  // we do this here (lazily) to avoid unneeded global pollution\n  if (!callbacks) {\n    // we need to consider multiple engines in the same page\n    if (!global.___eio) global.___eio = [];\n    callbacks = global.___eio;\n  }\n\n  // callback identifier\n  this.index = callbacks.length;\n\n  // add callback to jsonp global\n  var self = this;\n  callbacks.push(function (msg) {\n    self.onData(msg);\n  });\n\n  // append to query string\n  this.query.j = this.index;\n\n  // prevent spurious errors from being emitted when the window is unloaded\n  if (global.document && global.addEventListener) {\n    global.addEventListener('beforeunload', function () {\n      if (self.script) self.script.onerror = empty;\n    }, false);\n  }\n}\n\n/**\n * Inherits from Polling.\n */\n\ninherit(JSONPPolling, Polling);\n\n/*\n * JSONP only supports binary as base64 encoded strings\n */\n\nJSONPPolling.prototype.supportsBinary = false;\n\n/**\n * Closes the socket.\n *\n * @api private\n */\n\nJSONPPolling.prototype.doClose = function () {\n  if (this.script) {\n    this.script.parentNode.removeChild(this.script);\n    this.script = null;\n  }\n\n  if (this.form) {\n    this.form.parentNode.removeChild(this.form);\n    this.form = null;\n    this.iframe = null;\n  }\n\n  Polling.prototype.doClose.call(this);\n};\n\n/**\n * Starts a poll cycle.\n *\n * @api private\n */\n\nJSONPPolling.prototype.doPoll = function () {\n  var self = this;\n  var script = document.createElement('script');\n\n  if (this.script) {\n    this.script.parentNode.removeChild(this.script);\n    this.script = null;\n  }\n\n  script.async = true;\n  script.src = this.uri();\n  script.onerror = function (e) {\n    self.onError('jsonp poll error', e);\n  };\n\n  var insertAt = document.getElementsByTagName('script')[0];\n  if (insertAt) {\n    insertAt.parentNode.insertBefore(script, insertAt);\n  } else {\n    (document.head || document.body).appendChild(script);\n  }\n  this.script = script;\n\n  var isUAgecko = 'undefined' !== typeof navigator && /gecko/i.test(navigator.userAgent);\n\n  if (isUAgecko) {\n    setTimeout(function () {\n      var iframe = document.createElement('iframe');\n      document.body.appendChild(iframe);\n      document.body.removeChild(iframe);\n    }, 100);\n  }\n};\n\n/**\n * Writes with a hidden iframe.\n *\n * @param {String} data to send\n * @param {Function} called upon flush.\n * @api private\n */\n\nJSONPPolling.prototype.doWrite = function (data, fn) {\n  var self = this;\n\n  if (!this.form) {\n    var form = document.createElement('form');\n    var area = document.createElement('textarea');\n    var id = this.iframeId = 'eio_iframe_' + this.index;\n    var iframe;\n\n    form.className = 'socketio';\n    form.style.position = 'absolute';\n    form.style.top = '-1000px';\n    form.style.left = '-1000px';\n    form.target = id;\n    form.method = 'POST';\n    form.setAttribute('accept-charset', 'utf-8');\n    area.name = 'd';\n    form.appendChild(area);\n    document.body.appendChild(form);\n\n    this.form = form;\n    this.area = area;\n  }\n\n  this.form.action = this.uri();\n\n  function complete () {\n    initIframe();\n    fn();\n  }\n\n  function initIframe () {\n    if (self.iframe) {\n      try {\n        self.form.removeChild(self.iframe);\n      } catch (e) {\n        self.onError('jsonp polling iframe removal error', e);\n      }\n    }\n\n    try {\n      // ie6 dynamic iframes with target=\"\" support (thanks Chris Lambacher)\n      var html = '<iframe src=\"javascript:0\" name=\"' + self.iframeId + '\">';\n      iframe = document.createElement(html);\n    } catch (e) {\n      iframe = document.createElement('iframe');\n      iframe.name = self.iframeId;\n      iframe.src = 'javascript:0';\n    }\n\n    iframe.id = self.iframeId;\n\n    self.form.appendChild(iframe);\n    self.iframe = iframe;\n  }\n\n  initIframe();\n\n  // escape \\n to prevent it from being converted into \\r\\n by some UAs\n  // double escaping is required for escaped new lines because unescaping of new lines can be done safely on server-side\n  data = data.replace(rEscapedNewline, '\\\\\\n');\n  this.area.value = data.replace(rNewline, '\\\\n');\n\n  try {\n    this.form.submit();\n  } catch (e) {}\n\n  if (this.iframe.attachEvent) {\n    this.iframe.onreadystatechange = function () {\n      if (self.iframe.readyState === 'complete') {\n        complete();\n      }\n    };\n  } else {\n    this.iframe.onload = complete;\n  }\n};\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ../~/engine.io-client/lib/transports/polling-jsonp.js\n// module id = 488\n// module chunks = 1 4 8 9 11","/**\n * Module dependencies.\n */\n\nvar Transport = require('../transport');\nvar parser = require('engine.io-parser');\nvar parseqs = require('parseqs');\nvar inherit = require('component-inherit');\nvar yeast = require('yeast');\nvar debug = require('debug')('engine.io-client:websocket');\nvar BrowserWebSocket = global.WebSocket || global.MozWebSocket;\nvar NodeWebSocket;\nif (typeof window === 'undefined') {\n  try {\n    NodeWebSocket = require('ws');\n  } catch (e) { }\n}\n\n/**\n * Get either the `WebSocket` or `MozWebSocket` globals\n * in the browser or try to resolve WebSocket-compatible\n * interface exposed by `ws` for Node-like environment.\n */\n\nvar WebSocket = BrowserWebSocket;\nif (!WebSocket && typeof window === 'undefined') {\n  WebSocket = NodeWebSocket;\n}\n\n/**\n * Module exports.\n */\n\nmodule.exports = WS;\n\n/**\n * WebSocket transport constructor.\n *\n * @api {Object} connection options\n * @api public\n */\n\nfunction WS (opts) {\n  var forceBase64 = (opts && opts.forceBase64);\n  if (forceBase64) {\n    this.supportsBinary = false;\n  }\n  this.perMessageDeflate = opts.perMessageDeflate;\n  this.usingBrowserWebSocket = BrowserWebSocket && !opts.forceNode;\n  if (!this.usingBrowserWebSocket) {\n    WebSocket = NodeWebSocket;\n  }\n  Transport.call(this, opts);\n}\n\n/**\n * Inherits from Transport.\n */\n\ninherit(WS, Transport);\n\n/**\n * Transport name.\n *\n * @api public\n */\n\nWS.prototype.name = 'websocket';\n\n/*\n * WebSockets support binary\n */\n\nWS.prototype.supportsBinary = true;\n\n/**\n * Opens socket.\n *\n * @api private\n */\n\nWS.prototype.doOpen = function () {\n  if (!this.check()) {\n    // let probe timeout\n    return;\n  }\n\n  var uri = this.uri();\n  var protocols = void (0);\n  var opts = {\n    agent: this.agent,\n    perMessageDeflate: this.perMessageDeflate\n  };\n\n  // SSL options for Node.js client\n  opts.pfx = this.pfx;\n  opts.key = this.key;\n  opts.passphrase = this.passphrase;\n  opts.cert = this.cert;\n  opts.ca = this.ca;\n  opts.ciphers = this.ciphers;\n  opts.rejectUnauthorized = this.rejectUnauthorized;\n  if (this.extraHeaders) {\n    opts.headers = this.extraHeaders;\n  }\n  if (this.localAddress) {\n    opts.localAddress = this.localAddress;\n  }\n\n  try {\n    this.ws = this.usingBrowserWebSocket ? new WebSocket(uri) : new WebSocket(uri, protocols, opts);\n  } catch (err) {\n    return this.emit('error', err);\n  }\n\n  if (this.ws.binaryType === undefined) {\n    this.supportsBinary = false;\n  }\n\n  if (this.ws.supports && this.ws.supports.binary) {\n    this.supportsBinary = true;\n    this.ws.binaryType = 'nodebuffer';\n  } else {\n    this.ws.binaryType = 'arraybuffer';\n  }\n\n  this.addEventListeners();\n};\n\n/**\n * Adds event listeners to the socket\n *\n * @api private\n */\n\nWS.prototype.addEventListeners = function () {\n  var self = this;\n\n  this.ws.onopen = function () {\n    self.onOpen();\n  };\n  this.ws.onclose = function () {\n    self.onClose();\n  };\n  this.ws.onmessage = function (ev) {\n    self.onData(ev.data);\n  };\n  this.ws.onerror = function (e) {\n    self.onError('websocket error', e);\n  };\n};\n\n/**\n * Writes data to socket.\n *\n * @param {Array} array of packets.\n * @api private\n */\n\nWS.prototype.write = function (packets) {\n  var self = this;\n  this.writable = false;\n\n  // encodePacket efficient as it uses WS framing\n  // no need for encodePayload\n  var total = packets.length;\n  for (var i = 0, l = total; i < l; i++) {\n    (function (packet) {\n      parser.encodePacket(packet, self.supportsBinary, function (data) {\n        if (!self.usingBrowserWebSocket) {\n          // always create a new object (GH-437)\n          var opts = {};\n          if (packet.options) {\n            opts.compress = packet.options.compress;\n          }\n\n          if (self.perMessageDeflate) {\n            var len = 'string' === typeof data ? global.Buffer.byteLength(data) : data.length;\n            if (len < self.perMessageDeflate.threshold) {\n              opts.compress = false;\n            }\n          }\n        }\n\n        // Sometimes the websocket has already been closed but the browser didn't\n        // have a chance of informing us about it yet, in that case send will\n        // throw an error\n        try {\n          if (self.usingBrowserWebSocket) {\n            // TypeError is thrown when passing the second argument on Safari\n            self.ws.send(data);\n          } else {\n            self.ws.send(data, opts);\n          }\n        } catch (e) {\n          debug('websocket closed before onclose event');\n        }\n\n        --total || done();\n      });\n    })(packets[i]);\n  }\n\n  function done () {\n    self.emit('flush');\n\n    // fake drain\n    // defer to next tick to allow Socket to clear writeBuffer\n    setTimeout(function () {\n      self.writable = true;\n      self.emit('drain');\n    }, 0);\n  }\n};\n\n/**\n * Called upon close\n *\n * @api private\n */\n\nWS.prototype.onClose = function () {\n  Transport.prototype.onClose.call(this);\n};\n\n/**\n * Closes socket.\n *\n * @api private\n */\n\nWS.prototype.doClose = function () {\n  if (typeof this.ws !== 'undefined') {\n    this.ws.close();\n  }\n};\n\n/**\n * Generates uri for connection.\n *\n * @api private\n */\n\nWS.prototype.uri = function () {\n  var query = this.query || {};\n  var schema = this.secure ? 'wss' : 'ws';\n  var port = '';\n\n  // avoid port if default for schema\n  if (this.port && (('wss' === schema && Number(this.port) !== 443) ||\n    ('ws' === schema && Number(this.port) !== 80))) {\n    port = ':' + this.port;\n  }\n\n  // append timestamp to URI\n  if (this.timestampRequests) {\n    query[this.timestampParam] = yeast();\n  }\n\n  // communicate binary support capabilities\n  if (!this.supportsBinary) {\n    query.b64 = 1;\n  }\n\n  query = parseqs.encode(query);\n\n  // prepend ? to query\n  if (query.length) {\n    query = '?' + query;\n  }\n\n  var ipv6 = this.hostname.indexOf(':') !== -1;\n  return schema + '://' + (ipv6 ? '[' + this.hostname + ']' : this.hostname) + port + this.path + query;\n};\n\n/**\n * Feature detection for WebSocket.\n *\n * @return {Boolean} whether this transport is available.\n * @api public\n */\n\nWS.prototype.check = function () {\n  return !!WebSocket && !('__initialize' in WebSocket && this.name === WS.prototype.name);\n};\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ../~/engine.io-client/lib/transports/websocket.js\n// module id = 489\n// module chunks = 1 4 8 9 11","\nvar indexOf = [].indexOf;\n\nmodule.exports = function(arr, obj){\n  if (indexOf) return arr.indexOf(obj);\n  for (var i = 0; i < arr.length; ++i) {\n    if (arr[i] === obj) return i;\n  }\n  return -1;\n};\n\n\n//////////////////\n// WEBPACK FOOTER\n// ../~/indexof/index.js\n// module id = 491\n// module chunks = 1 4 8 9 11","/**\r\n * JSON parse.\r\n *\r\n * @see Based on jQuery#parseJSON (MIT) and JSON2\r\n * @api private\r\n */\r\n\r\nvar rvalidchars = /^[\\],:{}\\s]*$/;\r\nvar rvalidescape = /\\\\(?:[\"\\\\\\/bfnrt]|u[0-9a-fA-F]{4})/g;\r\nvar rvalidtokens = /\"[^\"\\\\\\n\\r]*\"|true|false|null|-?\\d+(?:\\.\\d*)?(?:[eE][+\\-]?\\d+)?/g;\r\nvar rvalidbraces = /(?:^|:|,)(?:\\s*\\[)+/g;\r\nvar rtrimLeft = /^\\s+/;\r\nvar rtrimRight = /\\s+$/;\r\n\r\nmodule.exports = function parsejson(data) {\r\n  if ('string' != typeof data || !data) {\r\n    return null;\r\n  }\r\n\r\n  data = data.replace(rtrimLeft, '').replace(rtrimRight, '');\r\n\r\n  // Attempt to parse using the native JSON parser first\r\n  if (global.JSON && JSON.parse) {\r\n    return JSON.parse(data);\r\n  }\r\n\r\n  if (rvalidchars.test(data.replace(rvalidescape, '@')\r\n      .replace(rvalidtokens, ']')\r\n      .replace(rvalidbraces, ''))) {\r\n    return (new Function('return ' + data))();\r\n  }\r\n};\n\n\n//////////////////\n// WEBPACK FOOTER\n// ../~/parsejson/index.js\n// module id = 492\n// module chunks = 1 4 8 9 11","\n/**\n * Module dependencies.\n */\n\nvar parser = require('socket.io-parser');\nvar Emitter = require('component-emitter');\nvar toArray = require('to-array');\nvar on = require('./on');\nvar bind = require('component-bind');\nvar debug = require('debug')('socket.io-client:socket');\nvar hasBin = require('has-binary');\n\n/**\n * Module exports.\n */\n\nmodule.exports = exports = Socket;\n\n/**\n * Internal events (blacklisted).\n * These events can't be emitted by the user.\n *\n * @api private\n */\n\nvar events = {\n  connect: 1,\n  connect_error: 1,\n  connect_timeout: 1,\n  connecting: 1,\n  disconnect: 1,\n  error: 1,\n  reconnect: 1,\n  reconnect_attempt: 1,\n  reconnect_failed: 1,\n  reconnect_error: 1,\n  reconnecting: 1,\n  ping: 1,\n  pong: 1\n};\n\n/**\n * Shortcut to `Emitter#emit`.\n */\n\nvar emit = Emitter.prototype.emit;\n\n/**\n * `Socket` constructor.\n *\n * @api public\n */\n\nfunction Socket (io, nsp, opts) {\n  this.io = io;\n  this.nsp = nsp;\n  this.json = this; // compat\n  this.ids = 0;\n  this.acks = {};\n  this.receiveBuffer = [];\n  this.sendBuffer = [];\n  this.connected = false;\n  this.disconnected = true;\n  if (opts && opts.query) {\n    this.query = opts.query;\n  }\n  if (this.io.autoConnect) this.open();\n}\n\n/**\n * Mix in `Emitter`.\n */\n\nEmitter(Socket.prototype);\n\n/**\n * Subscribe to open, close and packet events\n *\n * @api private\n */\n\nSocket.prototype.subEvents = function () {\n  if (this.subs) return;\n\n  var io = this.io;\n  this.subs = [\n    on(io, 'open', bind(this, 'onopen')),\n    on(io, 'packet', bind(this, 'onpacket')),\n    on(io, 'close', bind(this, 'onclose'))\n  ];\n};\n\n/**\n * \"Opens\" the socket.\n *\n * @api public\n */\n\nSocket.prototype.open =\nSocket.prototype.connect = function () {\n  if (this.connected) return this;\n\n  this.subEvents();\n  this.io.open(); // ensure open\n  if ('open' === this.io.readyState) this.onopen();\n  this.emit('connecting');\n  return this;\n};\n\n/**\n * Sends a `message` event.\n *\n * @return {Socket} self\n * @api public\n */\n\nSocket.prototype.send = function () {\n  var args = toArray(arguments);\n  args.unshift('message');\n  this.emit.apply(this, args);\n  return this;\n};\n\n/**\n * Override `emit`.\n * If the event is in `events`, it's emitted normally.\n *\n * @param {String} event name\n * @return {Socket} self\n * @api public\n */\n\nSocket.prototype.emit = function (ev) {\n  if (events.hasOwnProperty(ev)) {\n    emit.apply(this, arguments);\n    return this;\n  }\n\n  var args = toArray(arguments);\n  var parserType = parser.EVENT; // default\n  if (hasBin(args)) { parserType = parser.BINARY_EVENT; } // binary\n  var packet = { type: parserType, data: args };\n\n  packet.options = {};\n  packet.options.compress = !this.flags || false !== this.flags.compress;\n\n  // event ack callback\n  if ('function' === typeof args[args.length - 1]) {\n    debug('emitting packet with ack id %d', this.ids);\n    this.acks[this.ids] = args.pop();\n    packet.id = this.ids++;\n  }\n\n  if (this.connected) {\n    this.packet(packet);\n  } else {\n    this.sendBuffer.push(packet);\n  }\n\n  delete this.flags;\n\n  return this;\n};\n\n/**\n * Sends a packet.\n *\n * @param {Object} packet\n * @api private\n */\n\nSocket.prototype.packet = function (packet) {\n  packet.nsp = this.nsp;\n  this.io.packet(packet);\n};\n\n/**\n * Called upon engine `open`.\n *\n * @api private\n */\n\nSocket.prototype.onopen = function () {\n  debug('transport is open - connecting');\n\n  // write connect packet if necessary\n  if ('/' !== this.nsp) {\n    if (this.query) {\n      this.packet({type: parser.CONNECT, query: this.query});\n    } else {\n      this.packet({type: parser.CONNECT});\n    }\n  }\n};\n\n/**\n * Called upon engine `close`.\n *\n * @param {String} reason\n * @api private\n */\n\nSocket.prototype.onclose = function (reason) {\n  debug('close (%s)', reason);\n  this.connected = false;\n  this.disconnected = true;\n  delete this.id;\n  this.emit('disconnect', reason);\n};\n\n/**\n * Called with socket packet.\n *\n * @param {Object} packet\n * @api private\n */\n\nSocket.prototype.onpacket = function (packet) {\n  if (packet.nsp !== this.nsp) return;\n\n  switch (packet.type) {\n    case parser.CONNECT:\n      this.onconnect();\n      break;\n\n    case parser.EVENT:\n      this.onevent(packet);\n      break;\n\n    case parser.BINARY_EVENT:\n      this.onevent(packet);\n      break;\n\n    case parser.ACK:\n      this.onack(packet);\n      break;\n\n    case parser.BINARY_ACK:\n      this.onack(packet);\n      break;\n\n    case parser.DISCONNECT:\n      this.ondisconnect();\n      break;\n\n    case parser.ERROR:\n      this.emit('error', packet.data);\n      break;\n  }\n};\n\n/**\n * Called upon a server event.\n *\n * @param {Object} packet\n * @api private\n */\n\nSocket.prototype.onevent = function (packet) {\n  var args = packet.data || [];\n  debug('emitting event %j', args);\n\n  if (null != packet.id) {\n    debug('attaching ack callback to event');\n    args.push(this.ack(packet.id));\n  }\n\n  if (this.connected) {\n    emit.apply(this, args);\n  } else {\n    this.receiveBuffer.push(args);\n  }\n};\n\n/**\n * Produces an ack callback to emit with an event.\n *\n * @api private\n */\n\nSocket.prototype.ack = function (id) {\n  var self = this;\n  var sent = false;\n  return function () {\n    // prevent double callbacks\n    if (sent) return;\n    sent = true;\n    var args = toArray(arguments);\n    debug('sending ack %j', args);\n\n    var type = hasBin(args) ? parser.BINARY_ACK : parser.ACK;\n    self.packet({\n      type: type,\n      id: id,\n      data: args\n    });\n  };\n};\n\n/**\n * Called upon a server acknowlegement.\n *\n * @param {Object} packet\n * @api private\n */\n\nSocket.prototype.onack = function (packet) {\n  var ack = this.acks[packet.id];\n  if ('function' === typeof ack) {\n    debug('calling ack %s with %j', packet.id, packet.data);\n    ack.apply(this, packet.data);\n    delete this.acks[packet.id];\n  } else {\n    debug('bad ack %s', packet.id);\n  }\n};\n\n/**\n * Called upon server connect.\n *\n * @api private\n */\n\nSocket.prototype.onconnect = function () {\n  this.connected = true;\n  this.disconnected = false;\n  this.emit('connect');\n  this.emitBuffered();\n};\n\n/**\n * Emit buffered events (received and emitted).\n *\n * @api private\n */\n\nSocket.prototype.emitBuffered = function () {\n  var i;\n  for (i = 0; i < this.receiveBuffer.length; i++) {\n    emit.apply(this, this.receiveBuffer[i]);\n  }\n  this.receiveBuffer = [];\n\n  for (i = 0; i < this.sendBuffer.length; i++) {\n    this.packet(this.sendBuffer[i]);\n  }\n  this.sendBuffer = [];\n};\n\n/**\n * Called upon server disconnect.\n *\n * @api private\n */\n\nSocket.prototype.ondisconnect = function () {\n  debug('server disconnect (%s)', this.nsp);\n  this.destroy();\n  this.onclose('io server disconnect');\n};\n\n/**\n * Called upon forced client/server side disconnections,\n * this method ensures the manager stops tracking us and\n * that reconnections don't get triggered for this.\n *\n * @api private.\n */\n\nSocket.prototype.destroy = function () {\n  if (this.subs) {\n    // clean subscriptions to avoid reconnections\n    for (var i = 0; i < this.subs.length; i++) {\n      this.subs[i].destroy();\n    }\n    this.subs = null;\n  }\n\n  this.io.destroy(this);\n};\n\n/**\n * Disconnects the socket manually.\n *\n * @return {Socket} self\n * @api public\n */\n\nSocket.prototype.close =\nSocket.prototype.disconnect = function () {\n  if (this.connected) {\n    debug('performing disconnect (%s)', this.nsp);\n    this.packet({ type: parser.DISCONNECT });\n  }\n\n  // remove socket from pool\n  this.destroy();\n\n  if (this.connected) {\n    // fire events\n    this.onclose('io client disconnect');\n  }\n  return this;\n};\n\n/**\n * Sets the compress flag.\n *\n * @param {Boolean} if `true`, compresses the sending data\n * @return {Socket} self\n * @api public\n */\n\nSocket.prototype.compress = function (compress) {\n  this.flags = this.flags || {};\n  this.flags.compress = compress;\n  return this;\n};\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ../~/socket.io-client/lib/socket.js\n// module id = 493\n// module chunks = 1 4 8 9 11","module.exports = toArray\n\nfunction toArray(list, index) {\n    var array = []\n\n    index = index || 0\n\n    for (var i = index || 0; i < list.length; i++) {\n        array[i - index] = list[i]\n    }\n\n    return array\n}\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ../~/to-array/index.js\n// module id = 495\n// module chunks = 1 4 8 9 11","\n/**\n * Module exports.\n */\n\nmodule.exports = on;\n\n/**\n * Helper for subscriptions.\n *\n * @param {Object|EventEmitter} obj with `Emitter` mixin or `EventEmitter`\n * @param {String} event name\n * @param {Function} callback\n * @api public\n */\n\nfunction on (obj, ev, fn) {\n  obj.on(ev, fn);\n  return {\n    destroy: function () {\n      obj.removeListener(ev, fn);\n    }\n  };\n}\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ../~/socket.io-client/lib/on.js\n// module id = 496\n// module chunks = 1 4 8 9 11","/**\n * Slice reference.\n */\n\nvar slice = [].slice;\n\n/**\n * Bind `obj` to `fn`.\n *\n * @param {Object} obj\n * @param {Function|String} fn or string\n * @return {Function}\n * @api public\n */\n\nmodule.exports = function(obj, fn){\n  if ('string' == typeof fn) fn = obj[fn];\n  if ('function' != typeof fn) throw new Error('bind() requires a function');\n  var args = slice.call(arguments, 2);\n  return function(){\n    return fn.apply(obj, args.concat(slice.call(arguments)));\n  }\n};\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ../~/component-bind/index.js\n// module id = 497\n// module chunks = 1 4 8 9 11","\n/**\n * Expose `Backoff`.\n */\n\nmodule.exports = Backoff;\n\n/**\n * Initialize backoff timer with `opts`.\n *\n * - `min` initial timeout in milliseconds [100]\n * - `max` max timeout [10000]\n * - `jitter` [0]\n * - `factor` [2]\n *\n * @param {Object} opts\n * @api public\n */\n\nfunction Backoff(opts) {\n  opts = opts || {};\n  this.ms = opts.min || 100;\n  this.max = opts.max || 10000;\n  this.factor = opts.factor || 2;\n  this.jitter = opts.jitter > 0 && opts.jitter <= 1 ? opts.jitter : 0;\n  this.attempts = 0;\n}\n\n/**\n * Return the backoff duration.\n *\n * @return {Number}\n * @api public\n */\n\nBackoff.prototype.duration = function(){\n  var ms = this.ms * Math.pow(this.factor, this.attempts++);\n  if (this.jitter) {\n    var rand =  Math.random();\n    var deviation = Math.floor(rand * this.jitter * ms);\n    ms = (Math.floor(rand * 10) & 1) == 0  ? ms - deviation : ms + deviation;\n  }\n  return Math.min(ms, this.max) | 0;\n};\n\n/**\n * Reset the number of attempts.\n *\n * @api public\n */\n\nBackoff.prototype.reset = function(){\n  this.attempts = 0;\n};\n\n/**\n * Set the minimum duration\n *\n * @api public\n */\n\nBackoff.prototype.setMin = function(min){\n  this.ms = min;\n};\n\n/**\n * Set the maximum duration\n *\n * @api public\n */\n\nBackoff.prototype.setMax = function(max){\n  this.max = max;\n};\n\n/**\n * Set the jitter\n *\n * @api public\n */\n\nBackoff.prototype.setJitter = function(jitter){\n  this.jitter = jitter;\n};\n\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ../~/backo2/index.js\n// module id = 498\n// module chunks = 1 4 8 9 11","import { Component, Input } from '@angular/core';\n\nimport { BaseOutputSensor } from '../shared/base-output-sensor/base-output-sensor';\nimport { DeviceWidgetService } from '../device-widget.service';\n\n@Component({\n    selector: 'sh-servo-widget',\n    template: require('./servo-widget.template.html'),\n    styles: [\n        require('../device-widget.style.scss'),\n        require('./servo-widget.style.scss')\n    ]\n})\nexport class ServoWidgetComponent extends BaseOutputSensor {\n\n    @Input() device;\n\n    constructor(sensorWidgetService: DeviceWidgetService) {\n        super(sensorWidgetService);\n    }\n\n    changeDegree() {\n        return this.pushEvent(true, this.data.value);\n    }\n}\n\n\n\n// WEBPACK FOOTER //\n// ../~/angular2-template-loader!./app/devices/device-widgets/servo-widget/servo-widget.component.ts","import { BaseSensor } from '../base-sensor/base-sensor';\nimport { DeviceWidgetService } from '../../device-widget.service';\n\nexport const DEVICE_ON_STATE = 'ON';\nexport const DEVICE_OFF_STATE = 'OFF';\nexport const DEVICE_RESPOND_TIMEOUT = 1000;\n\nconst pending = Symbol('pending');\nconst timeout = Symbol('timeout');\n\nexport class BaseOutputSensor extends BaseSensor {\n\n    static getConditionResult(condition, self, args) {\n        const isFunction = f => typeof f === 'function';\n        return isFunction(condition) ? condition.apply(self, args) : condition;\n    }\n\n    static generateValue(condition, positiveValue, negativeValue= null, self?, args?) {\n        return BaseOutputSensor.getConditionResult(condition, self, args) ? positiveValue : negativeValue;\n    }\n\n    constructor(sensorWidgetService: DeviceWidgetService) {\n        super(sensorWidgetService);\n        this[pending] = null;\n    }\n\n    toDeviceRepresentation(value) {\n        return value;\n    }\n\n    fromDeviceRepresentation(value) {\n        return value;\n    }\n\n    onDeviceDataChanged(data) {\n        // NOTE: mqtt is slow and sends us false information for some time after toggle\n        // we just don`t listen to socket (and mqtt) for some time to let it switch state\n        if (this[pending] !== null) {\n            return;\n        }\n\n        if (this.device.mqttId === data.device) {\n            const rawValue = BaseOutputSensor.generateValue(true, data.value);\n            this.data.value = this.fromDeviceRepresentation(rawValue);\n            this.data.updateTime = new Date();\n        }\n    }\n\n    pushEvent(condition, positiveValue, negativeValue= null, self?, args?) {\n        this[pending] = true;\n\n        clearTimeout(this[timeout]);\n\n        this[timeout] = setTimeout(() => {\n            this[pending] = null;\n        }, DEVICE_RESPOND_TIMEOUT);\n\n        this.data.value = BaseOutputSensor.generateValue(condition, positiveValue, negativeValue, self, args);\n        this.data.updateTime = new Date();\n\n        this.sensorWidgetService.pushEvent({\n            device: this.device.mqttId,\n            value: this.toDeviceRepresentation(this.data.value)\n        });\n    }\n}\n\n\n\n// WEBPACK FOOTER //\n// ../~/angular2-template-loader!./app/devices/device-widgets/shared/base-output-sensor/base-output-sensor.ts","import { OnInit, OnDestroy } from '@angular/core';\nimport { DeviceWidgetService } from '../../device-widget.service';\n\nexport class BaseSensor implements OnInit, OnDestroy {\n\n    protected data: {\n        value: string|number|boolean|null,\n        updateTime: Date|null\n    };\n    protected device: {\n        mqttId: string,\n        value: string|number|boolean|null,\n        valueUpdated: string\n    };\n\n    constructor(protected sensorWidgetService: DeviceWidgetService) {}\n\n    ngOnInit() {\n        this.data = {\n            value: this.device.value || null,\n            updateTime: this.device.valueUpdated ? new Date(this.device.valueUpdated) : null\n        };\n        this.sensorWidgetService\n            .subscribe(this.device.mqttId, data => this.onDeviceDataChanged(data));\n    }\n\n    onDeviceDataChanged(data) {\n        if (this.device.mqttId === data.device) {\n            this.data = data;\n            this.data.updateTime = new Date();\n        }\n    }\n\n    ngOnDestroy() {\n        this.sensorWidgetService\n            .unsubscribe(this.device.mqttId);\n    }\n}\n\n\n\n// WEBPACK FOOTER //\n// ../~/angular2-template-loader!./app/devices/device-widgets/shared/base-sensor/base-sensor.ts","module.exports = \"<div class=\\\"sensor-widget_info\\\">\\n    <div class=\\\"sensor-widget_info_value\\\">\\n        <div class=\\\"sensor-servo-widget_label\\\">\\n            <div class=\\\"sensor-servo-widget_label-left\\\">0</div>\\n            <div class=\\\"sensor-servo-widget_label-right\\\">180</div>\\n        </div>\\n        <input class=\\\"sensor-servo-widget_controller\\\" type=\\\"range\\\" [min]=\\\"0\\\" [max]=\\\"180\\\" [(ngModel)]=\\\"data.value\\\"\\n               (change)=\\\"changeDegree()\\\">\\n\\n        <div class=\\\"sensor-servo-widget_value_wrap\\\">\\n            <span [hidden]=\\\"data.value===undefined\\\">{{data.value}} {{device.metrics}}</span>\\n        </div>\\n    </div>\\n</div>\\n<div class=\\\"sensor-widget_footer\\\"\\n     [hidden]=\\\"data.updateTime===undefined\\\">\\n    {{data.updateTime | date:\\\"MM.dd.y HH:mm:ss\\\" }}\\n</div>\\n\"\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./app/devices/device-widgets/servo-widget/servo-widget.template.html\n// module id = 502\n// module chunks = 1 4 8 9","module.exports = \".sensor-servo-widget_label{font-size:10px;margin-bottom:12px;font-weight:normal;position:relative;top:12px}.sensor-servo-widget_label-left{float:left}.sensor-servo-widget_label-right{float:right}.sensor-servo-widget_label:after{clear:both}.sensor-servo-widget_value_wrap{overflow:hidden;white-space:nowrap;text-overflow:ellipsis;font-size:20px}.sensor-widget_info input[type=range]{-webkit-appearance:none;width:100%;background:transparent;border-color:transparent;color:transparent;margin:0 0 10px 0}.sensor-widget_info input[type=range]::-webkit-slider-thumb{-webkit-appearance:none;width:29px;height:29px;border-radius:29px;background-color:#ffffff;margin-top:-14px;box-shadow:0 4px 8px 0 rgba(0,0,0,0.19);border:solid 0.5px rgba(0,0,0,0.1);cursor:pointer}.sensor-widget_info input[type=range]::-moz-range-thumb{width:29px;height:29px;border-radius:29px;background-color:#ffffff;margin-top:-14px;box-shadow:0 4px 8px 0 rgba(0,0,0,0.19);border:solid 0.5px rgba(0,0,0,0.1);cursor:pointer}.sensor-widget_info input[type=range]::-ms-thumb{width:29px;height:29px;border-radius:29px;background-color:#ffffff;margin-top:-14px;box-shadow:0 4px 8px 0 rgba(0,0,0,0.19);border:solid 0.5px rgba(0,0,0,0.1);cursor:pointer}\\n\"\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./app/devices/device-widgets/servo-widget/servo-widget.style.scss\n// module id = 503\n// module chunks = 1 4 8 9","import { Component, Input } from '@angular/core';\n\nimport {\n    BaseOutputSensor,\n    DEVICE_ON_STATE,\n    DEVICE_OFF_STATE\n} from '../shared/base-output-sensor/base-output-sensor';\nimport { DeviceWidgetService } from '../device-widget.service';\n\n@Component({\n    selector: 'sh-switcher-widget',\n    template: require('./switcher-widget.template.html'),\n    styles: [\n        require('./switcher-widget.style.scss'),\n        require('../device-widget.style.scss')\n    ]\n})\nexport class SwitcherWidgetComponent extends BaseOutputSensor {\n\n    @Input() device;\n\n    fromDeviceRepresentation(value) {\n        return value === DEVICE_ON_STATE;\n    }\n\n    constructor(sensorWidgetService: DeviceWidgetService) {\n        super(sensorWidgetService);\n    }\n\n    switchExecutor($event) {\n        return this.pushEvent($event.target.checked, DEVICE_ON_STATE, DEVICE_OFF_STATE);\n    }\n}\n\n\n\n// WEBPACK FOOTER //\n// ../~/angular2-template-loader!./app/devices/device-widgets/switcher-widget/switcher-widget.component.ts","module.exports = \"<div class=\\\"sensor-widget_switcher-info\\\">\\n    <div class=\\\"sensor-widget_info_value\\\">\\n        <div class=\\\"sh-switch\\\">\\n            <label>\\n                <input type=\\\"checkbox\\\"\\n                       [(ngModel)]=\\\"data.value\\\"\\n                       (change)=\\\"switchExecutor($event)\\\">\\n                <span class=\\\"sh-lever\\\"></span>\\n            </label>\\n        </div>\\n        <div class=\\\"sensor-widget_info_value--wrap\\\">\\n            <span [hidden]=\\\"data.value===undefined\\\">{{data.value ? 'ON': 'OFF'}}</span>\\n        </div>\\n    </div>\\n</div>\\n<div class=\\\"sensor-widget_footer\\\"\\n     [hidden]=\\\"data.updateTime===undefined\\\">\\n    {{data.updateTime | date:\\\"MM.dd.y HH:mm:ss\\\" }}\\n</div>\\n\"\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./app/devices/device-widgets/switcher-widget/switcher-widget.template.html\n// module id = 505\n// module chunks = 1 4 8 9","module.exports = \".sh-switch,.sh-switch *{-webkit-user-select:none;-moz-user-select:none;-khtml-user-select:none;-ms-user-select:none}.sh-switch label{cursor:pointer}.sh-switch label input[type=checkbox]+.sh-lever{background-color:#fff}.sh-switch label input[type=checkbox]{opacity:0;width:0;height:0}.sh-switch label input[type=checkbox]:checked+.sh-lever{background-color:#9AC352}.sh-switch label input[type=checkbox]:checked+.sh-lever:after{background-color:#FFFFFF;left:2px;top:2px}.sh-switch label .sh-lever{content:\\\"\\\";display:inline-block;position:relative;width:33px;height:58px;background-color:#FFFFFF;border-radius:16px;margin-right:10px;transition:background 0.3s ease;vertical-align:middle;margin:12px 0}.sh-switch label .sh-lever:after{content:\\\"\\\";position:absolute;display:inline-block;width:29px;height:29px;border-radius:29px;box-shadow:0 1px 3px 1px rgba(0,0,0,0.19);left:2px;top:27px;transition:left 0.3s ease, background .3s ease, box-shadow 0.1s ease}input[type=checkbox]:checked:not(:disabled) ~ .sh-lever:active::after,input[type=checkbox]:checked:not(:disabled).tabbed:focus ~ .sh-lever::after{box-shadow:0 1px 3px 1px rgba(0,0,0,0.4),0 0 0 15px rgba(154,195,82,0.1)}input[type=checkbox]:not(:disabled) ~ .sh-lever:active:after,input[type=checkbox]:not(:disabled).tabbed:focus ~ .sh-lever::after{box-shadow:0 1px 3px 1px rgba(0,0,0,0.4),0 0 0 15px rgba(0,0,0,0.08)}.switch input[type=checkbox][disabled]+.sh-lever{cursor:default}.switch label input[type=checkbox][disabled]+.sh-lever:after,.switch label input[type=checkbox][disabled]:checked+.sh-lever:after{background-color:#777}\\n\"\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./app/devices/device-widgets/switcher-widget/switcher-widget.style.scss\n// module id = 506\n// module chunks = 1 4 8 9","import { Component, Input } from '@angular/core';\nimport { DeviceWidgetService } from '../device-widget.service';\n\nimport { BaseSensor } from '../shared/base-sensor/base-sensor';\n\n@Component({\n    selector: 'sh-sensor-widget',\n    template: require('./sensor-widget.template.html'),\n    styles: [\n        require('../device-widget.style.scss')\n    ]\n})\nexport class SensorWidgetComponent extends BaseSensor {\n\n    @Input() device;\n\n    constructor(sensorWidgetService: DeviceWidgetService) {\n        super(sensorWidgetService);\n    }\n}\n\n\n\n// WEBPACK FOOTER //\n// ../~/angular2-template-loader!./app/devices/device-widgets/sensor-widget/sensor-widget.component.ts","module.exports = \"<div class=\\\"sensor-widget_info\\\">\\n    <div class=\\\"sensor-widget_info_value\\\">\\n        <span [hidden]=\\\"data.value===undefined\\\">{{data.value}} {{device.metrics}}</span>\\n        <span [hidden]=\\\"data.value\\\">.</span>\\n    </div>\\n</div>\\n<div class=\\\"sensor-widget_footer\\\"\\n     [hidden]=\\\"data.updateTime===undefined\\\">\\n    {{data.updateTime | date:\\\"MM.dd.y HH:mm:ss\\\" }}\\n</div>\\n\"\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./app/devices/device-widgets/sensor-widget/sensor-widget.template.html\n// module id = 508\n// module chunks = 1 4 8 9","import { NgModule } from '@angular/core';\nimport { RouterModule } from '@angular/router';\nimport { FormsModule } from '@angular/forms';\n\nimport { SharedModule } from '../shared/shared.module';\nimport { DevicesModule } from '../devices/devices.module';\n\nimport { routing } from './scenarios.routing';\n\nimport { ScenarioListResolveService } from './scenarios-list/scenario-list.resolve.service';\nimport { ScenarioStatusService } from './scenarios-list/scenario-status.service';\nimport { ScenarioService } from './shared/scenario.service';\n\nimport SCENARIOS_DECLARATIONS from './scenarios.declarations';\n\n@NgModule({\n    id: module.id,\n    imports: [\n        RouterModule,\n        FormsModule,\n        SharedModule,\n        DevicesModule,\n        routing\n    ],\n    declarations: [ ...SCENARIOS_DECLARATIONS ],\n    exports: [ ...SCENARIOS_DECLARATIONS ],\n    providers: [\n        ScenarioListResolveService,\n        ScenarioStatusService,\n        ScenarioService\n    ]\n})\nexport class ScenariosModule {}\n\n\n\n// WEBPACK FOOTER //\n// ../~/angular2-template-loader!./app/scenarios/scenarios.module.ts","import { RouterModule } from '@angular/router';\n\nimport {\n    CreateScenarioEditorComponent\n} from './scenario-details/editor/create-scenario-editor/create-scenario-editor.component';\nimport {\n    EditScenarioEditorComponent\n} from './scenario-details/editor/edit-scenario-editor/edit-scenario-editor.component';\nimport {\n    CreateScenarioWizardComponent\n} from './scenario-details/wizard/create-scenario-wizard/create-scenario-wizard.component';\nimport {\n    EditScenarioWizardComponent\n} from './scenario-details/wizard/edit-scenario-wizard/edit-scenario-wizard.component';\nimport { ScenarioListComponent } from './scenarios-list/scenario-list.component';\n\nimport { ScenarioListResolveService } from './scenarios-list/scenario-list.resolve.service';\n\nexport const routes = [\n    {\n        path: '',\n        children: [\n            {\n                path: '', component: ScenarioListComponent,\n                resolve: {scenarioList: ScenarioListResolveService}\n            },\n            {\n                path: 'editor-create',\n                component: CreateScenarioEditorComponent\n            },\n            {\n                path: 'wizard-create',\n                component: CreateScenarioWizardComponent\n            },\n            {\n                path: 'editor/:id',\n                component: EditScenarioEditorComponent\n            },\n            {\n                path: 'wizard/:id',\n                component: EditScenarioWizardComponent\n            },\n        ]\n    }\n];\n\nexport const routing = RouterModule.forChild(routes);\n\n\n\n// WEBPACK FOOTER //\n// ../~/angular2-template-loader!./app/scenarios/scenarios.routing.ts","import { Component } from '@angular/core';\nimport { ActivatedRoute, Router } from '@angular/router';\n\nimport { ScenarioService } from '../../../shared/scenario.service';\nimport { ScenarioDetailsComponent } from '../../scenario-details.component';\n\n@Component({\n    template: require('./create-scenario-editor.template.html'),\n    styles: [require('./scenario-editor.style.scss')]\n})\nexport class CreateScenarioEditorComponent extends ScenarioDetailsComponent {\n\n    constructor(_scenarioService: ScenarioService, _route: ActivatedRoute, _router: Router) {\n        super(_scenarioService, _route, _router);\n    }\n\n    save(scenario) {\n        this._scenarioService.create(scenario)\n            .subscribe(() => this.back());\n    }\n\n    onScenarioBodyUpdate({scenarioBody}) {\n        this.scenario['body'] = scenarioBody;\n    }\n}\n\n\n\n// WEBPACK FOOTER //\n// ../~/angular2-template-loader!./app/scenarios/scenario-details/editor/create-scenario-editor/create-scenario-editor.component.ts","import { Injectable } from '@angular/core';\nimport { ShHttpService } from '../../core/sh-http/sh-http.service';\n\n// TODO: let's use 'streams' approach. All promises functions should be\n// removed in future after refactoring\n@Injectable()\nexport class ScenarioService {\n    constructor(private http: ShHttpService) {\n        this.http = http;\n    }\n\n    get(id = '') {\n        return this.http.get(`/scenarios/${id}`);\n    }\n\n    update(scenario, isWizard?) { // TODO: use separate service for mapping wizard\n        return this.http.put(`/scenarios/${scenario.id}`, getScenario(scenario, isWizard));\n    }\n\n    create(scenario, isWizard?) { // TODO: use separate service for mapping wizard\n        return this.http.post('/scenarios', getScenario(scenario, isWizard));\n    }\n\n    delete(scenario) {\n        return this.http.delete(`/scenarios/${scenario.id}`);\n    }\n\n}\n\nfunction getScenario(scenario, isWizard) {\n    return isWizard ? mapScenario(scenario) : cleanScenario(scenario);\n}\n\nfunction cleanScenario(scenario) {\n    const result = Object.assign({}, scenario);\n    delete result.sourceType;\n    delete result.wizard;\n    return result;\n}\n\nfunction mapScenario(scenario) {\n    const logicalOperator = scenario.wizard.logicalOperator;\n    const conditions = getConditions(scenario.wizard.conditions);\n    const actions = getActions(scenario.wizard.actions);\n\n    return Object.assign({}, scenario, {\n        isConvertable: true,\n        body: '',                   // <- erasing any existing script\n        wizard: {\n            logicalOperator,\n            conditions,\n            actions\n        }\n    });\n\n    function getConditions(_conditions) {\n        return _conditions.map(condition => ({\n            device: condition.selectedDevice,\n            condition: condition.selectedCondition,\n            value: condition.value\n        }));\n    }\n\n    function getActions(_actions) {\n        return _actions.map(item => ({\n            device: item.selectedDevice,\n            value: item.value\n        }));\n    }\n}\n\n\n\n// WEBPACK FOOTER //\n// ../~/angular2-template-loader!./app/scenarios/shared/scenario.service.ts","import { Component } from '@angular/core';\nimport { ActivatedRoute, Router } from '@angular/router';\n\nimport { ScenarioService } from '../shared/scenario.service';\nimport { Scenario } from '../scenario-details/wizard/scenario-entities/scenario';\n\n@Component({\n    selector: 'sh-scenario-list',\n    template: require('./scenario-details.template.html'),\n    styles: [require('./scenario-details.style.scss')]\n})\nexport class ScenarioDetailsComponent {\n\n    protected scenario: Scenario;\n\n    // TODO remove route:ActivatedRoute to null\n    constructor(\n        protected _scenarioService: ScenarioService,\n        protected _route: ActivatedRoute,\n        protected _router: Router\n    ) {\n        this.scenario = new Scenario;\n    }\n\n    onScenarioBodyUpdate({scenarioBody}) {\n        this.scenario['body'] = scenarioBody;\n    }\n\n    back() {\n        this._router.navigate(['/scenarios']);\n    }\n}\n\n\n\n// WEBPACK FOOTER //\n// ../~/angular2-template-loader!./app/scenarios/scenario-details/scenario-details.component.ts","const DEFAULT_SCENARIO_STATE = {\n    active: false,\n    isConvertable: false\n};\n\nexport class Scenario {\n    constructor(data = {}) {\n        Object.assign(\n            this,\n            DEFAULT_SCENARIO_STATE,\n            {\n                wizard: {} // create empty wizard object if needed\n            },\n            data\n        );\n    }\n}\n\n\n\n// WEBPACK FOOTER //\n// ../~/angular2-template-loader!./app/scenarios/scenario-details/wizard/scenario-entities/scenario.ts","module.exports = \"<div class=\\\"page-header\\\">\\n    <div class=\\\"row\\\">\\n        <div class=\\\"col s3\\\">\\n            <a class=\\\"back-link valign-wrapper\\\" (click)=\\\"back()\\\">\\n                <i class=\\\"material-icons md-18\\\">navigate_before</i>\\n                Back to list\\n            </a>\\n        </div>\\n        <div class=\\\"col s12\\\" *ngIf=\\\"isWizardAvailable()\\\">\\n            <a [routerLink]=\\\"['../wizard-create']\\\" class=\\\"nav-link right\\\">\\n                <i class=\\\"material-icons\\\">edit</i>\\n                Go to Wizard\\n            </a>\\n        </div>\\n    </div>\\n</div>\\n\\n<form class=\\\"scenario-details\\\"\\n       (ngSubmit)=\\\"save(scenario)\\\"\\n       #scenarioDetailsForm=\\\"ngForm\\\">\\n    <label>\\n        Scenario name:\\n        <input [(ngModel)]=\\\"scenario.name\\\"\\n               name=\\\"name\\\"\\n               #name=\\\"ngModel\\\"\\n               class=\\\"black-text\\\"\\n               type=\\\"text\\\"/>\\n    </label>\\n\\n    <p class=\\\"sensor-detail__status\\\">\\n        <input [(ngModel)]=\\\"scenario.active\\\"\\n               name=\\\"active\\\"\\n               #active=\\\"ngModel\\\"\\n               class=\\\"filled-in sensor-detail__status-value\\\"\\n               type=\\\"checkbox\\\" id=\\\"scenario-details__status\\\"/>\\n        <label for=\\\"scenario-details__status\\\">Active</label>\\n    </p>\\n\\n    <label>\\n        Scenario description:\\n        <input [(ngModel)]=\\\"scenario.description\\\"\\n               name=\\\"description\\\"\\n               #description=\\\"ngModel\\\"\\n               class=\\\"black-text\\\"\\n               type=\\\"text\\\"/>\\n    </label>\\n\\n    <div class=\\\"scenario-details_editor-wrapper\\\">\\n        <sh-scenario-editor\\n            [scenario]=\\\"scenario?.body\\\"\\n            (updateScenario)=\\\"onScenarioBodyUpdate($event)\\\">\\n        </sh-scenario-editor>\\n    </div>\\n\\n    <button class=\\\"waves-effect waves-light btn blue-grey darken-1\\\"\\n            type=\\\"submit\\\"\\n            [disabled]=\\\"!scenarioDetailsForm.valid\\\">\\n        SAVE SCENARIO\\n    </button>\\n    <button (click)=\\\"delete(scenario)\\\"\\n            type=\\\"button\\\"\\n            class=\\\"waves-effect waves-light btn blue-grey darken-1\\\">\\n        Remove SCENARIO\\n    </button>\\n\\n</form>\\n\"\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./app/scenarios/scenario-details/scenario-details.template.html\n// module id = 568\n// module chunks = 4","module.exports = \".scenario-details_editor-wrapper{padding:20px 0 30px}.scenario-details a .label{display:block}\\n\"\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./app/scenarios/scenario-details/scenario-details.style.scss\n// module id = 569\n// module chunks = 4","module.exports = \"<div class=\\\"page-header\\\">\\n    <div class=\\\"row\\\">\\n        <div class=\\\"col s3\\\">\\n            <a class=\\\"back-link\\\" (click)=\\\"back()\\\">\\n                <i class=\\\"material-icons md-18\\\">navigate_before</i>\\n                Back to list\\n            </a>\\n        </div>\\n    </div>\\n    <div class=\\\"row\\\">\\n        <div class=\\\"col s7\\\">\\n            <h1>New scenario</h1>\\n        </div>\\n        <div class=\\\"col s5\\\">\\n            <a [routerLink]=\\\"['../wizard-create']\\\" class=\\\"nav-link right\\\">\\n                <i class=\\\"material-icons\\\">edit</i>\\n                Go to Wizard\\n            </a>\\n        </div>\\n    </div>\\n</div>\\n\\n<form class=\\\"scenario-details\\\" (ngSubmit)=\\\"save(scenario)\\\">\\n    <label>\\n        Scenario name: <b class=\\\"red-text\\\">*</b>\\n        <input [(ngModel)]=\\\"scenario.name\\\"\\n               name=\\\"name\\\"\\n               #name=\\\"ngModel\\\"\\n               class=\\\"black-text\\\"\\n               type=\\\"text\\\"\\n               required\\n               />\\n    </label>\\n    <div [hidden]=\\\"!name.touched || name.valid\\\" class=\\\"red-text text-darken-4\\\">\\n        Name should be filled\\n    </div>\\n\\n    <p class=\\\"sensor-detail__status\\\">\\n        <input [(ngModel)]=\\\"scenario.active\\\"\\n               name=\\\"active\\\"\\n               #active=\\\"ngModel\\\"\\n               class=\\\"filled-in sensor-detail__status-value\\\"\\n               type=\\\"checkbox\\\" id=\\\"scenario-details__status\\\"/>\\n        <label for=\\\"scenario-details__status\\\">active </label>\\n    </p>\\n\\n    <label>\\n        Scenario description:\\n        <input [(ngModel)]=\\\"scenario.description\\\"\\n               name=\\\"description\\\"\\n               #description=\\\"ngModel\\\"\\n               class=\\\"black-text\\\"\\n               type=\\\"text\\\"/>\\n    </label>\\n\\n    <div class=\\\"scenario-details_editor-wrapper\\\">\\n        <sh-scenario-editor\\n            [scenario]=\\\"scenario?.body\\\"\\n            (updateScenario)=\\\"onScenarioBodyUpdate($event)\\\">\\n        </sh-scenario-editor>\\n    </div>\\n\\n    <button class=\\\"waves-effect waves-light btn blue-grey darken-1\\\" type=\\\"submit\\\">SAVE SCENARIO</button>\\n</form>\\n\"\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./app/scenarios/scenario-details/editor/create-scenario-editor/create-scenario-editor.template.html\n// module id = 570\n// module chunks = 4","module.exports = \".scenario_item__body{max-height:6em;overflow:hidden}.scenario-details_editor-wrapper{padding:20px 0 30px}.scenario-details a .label{display:block}\\n\"\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./app/scenarios/scenario-details/editor/create-scenario-editor/scenario-editor.style.scss\n// module id = 571\n// module chunks = 4","import { Component, OnInit, ViewContainerRef } from '@angular/core';\nimport { ActivatedRoute, Router } from '@angular/router';\n\nimport { ScenarioDetailsComponent } from '../../scenario-details.component';\nimport { ScenarioService } from '../../../shared/scenario.service';\nimport { DialogService } from '../../../../shared/dialog/dialog.service';\n\n@Component({\n    selector: 'sh-scenario-list',\n    template: require('../../scenario-details.template.html'),\n    styles: [require('../../scenario-details.style.scss')]\n})\nexport class EditScenarioEditorComponent extends ScenarioDetailsComponent implements OnInit {\n\n    constructor(protected scenarioListService: ScenarioService,\n                protected router: Router,\n                protected route: ActivatedRoute,\n                protected dialogService: DialogService,\n                protected viewContainerRef: ViewContainerRef) {\n        super(scenarioListService, route, router);\n    }\n\n    public ngOnInit(): void {\n        this._scenarioService.get(this._route.snapshot.params['id'])\n            .subscribe((scenario) => {\n                this.scenario = scenario;\n            });\n    }\n\n    public save(scenario): void {\n        this._scenarioService.update(scenario)\n            .subscribe(() => {\n                this.back();\n            });\n    }\n\n    public delete(scenario): void {\n        const confirmOptions = {\n            title: '',\n            message: 'Are you sure you want to delete this scenario?'\n        };\n\n        this.dialogService.confirm(this.viewContainerRef, confirmOptions)\n            .filter(isConfirmed => isConfirmed)\n            .subscribe(() => {\n                this._scenarioService\n                    .delete(scenario)\n                    .subscribe(() => {\n                        this.back();\n                    });\n            });\n    }\n\n    public isWizardAvailable(): boolean {\n        return false;\n    }\n}\n\n\n\n// WEBPACK FOOTER //\n// ../~/angular2-template-loader!./app/scenarios/scenario-details/editor/edit-scenario-editor/edit-scenario-editor.component.ts","import { Component, OnInit } from '@angular/core';\nimport { ActivatedRoute, Router } from '@angular/router';\n\nimport { DevicesService } from '../../../../devices/devices.service';\n\nimport { ScenarioDetailsComponent } from '../../scenario-details.component';\nimport { ScenarioService } from '../../../shared/scenario.service';\n\nimport { Action } from '../scenario-entities/action';\nimport { Condition } from '../scenario-entities/condition';\nimport { Scenario } from '../scenario-entities/scenario';\n\n@Component({\n    template: require('./create-scenario-wizard.template.html'),\n})\nexport class CreateScenarioWizardComponent extends ScenarioDetailsComponent implements OnInit {\n    protected devices: Array<Object>;\n\n    constructor(\n        protected _scenarioService: ScenarioService,\n        protected _route: ActivatedRoute,\n        protected _router: Router,\n        protected devicesService: DevicesService\n    ) {\n        super(_scenarioService, _route, _router);\n    }\n\n    ngOnInit() {\n        this.devicesService\n            .getSensors()\n            .subscribe(devices => {\n                this.devices = devices;\n                const newScenario = {\n                    wizard: {\n                        conditions: [new Condition(devices)],\n                        actions: [new Action(devices)]\n                    }\n                };\n                this.scenario = new Scenario(newScenario);\n            });\n    }\n\n    onAddCriteria() {\n        this.scenario['wizard']['conditions'].push(new Condition(this.devices));\n    }\n\n    onRemoveCriteria(index) {\n        this.scenario['wizard']['conditions'].splice(index, 1);\n    }\n\n    onAddAction() {\n        this.scenario['wizard']['actions'].push(new Action(this.devices));\n    }\n\n    onRemoveAction(index) {\n        this.scenario['wizard']['actions'].splice(index, 1);\n    }\n\n    save(scenario) {\n        this._scenarioService.create(scenario, true)\n            .subscribe(() => this.back());\n    }\n}\n\n\n\n// WEBPACK FOOTER //\n// ../~/angular2-template-loader!./app/scenarios/scenario-details/wizard/create-scenario-wizard/create-scenario-wizard.component.ts","export class Action {\n\n    public selectedDevice;\n    public values;\n    public value;\n\n    constructor(public devices, initOptions = {value: '', device: null}) {\n\n        this.selectedDevice = initOptions.device;\n        this.values = [\n            {id: 'ON', name: 'Turn ON'}, {id: 'OFF', name: 'Turn OFF'}\n        ];\n        this.value = initOptions.value;\n    }\n}\n\n\n\n// WEBPACK FOOTER //\n// ../~/angular2-template-loader!./app/scenarios/scenario-details/wizard/scenario-entities/action.ts","export class Condition {\n\n    public selectedDevice;\n    public selectedCondition;\n    public conditions;\n    public value;\n\n    constructor(public devices, initOptions = {device: null, value: '', condition: null}) {\n\n        this.selectedDevice = initOptions.device;\n        this.conditions = [\n            {id: 'GREATER_THAN', name: 'GREATER THAN', sign: '>'},\n            {id: 'GREATER_THAN_OR_EQUAL_TO', name: 'GREATER OR EQUAL', sign: '>='},\n            {id: 'LESS_THAN', name: 'LESS THAN', sign: '<'},\n            {id: 'LESS_THAN_OR_EQUAL_TO', name: 'LESS THAN OR EQUAL TO', sign: '<='},\n            {id: 'EQUAL_TO', name: 'EQUAL TO', sign: '=='},\n            {id: 'NOT_EQUAL', name: 'NOT EQUAL', sign: '!='}\n        ];\n        this.selectedCondition = initOptions.condition;\n        this.value = initOptions.value;\n    }\n}\n\n\n\n// WEBPACK FOOTER //\n// ../~/angular2-template-loader!./app/scenarios/scenario-details/wizard/scenario-entities/condition.ts","module.exports = \"<div class=\\\"page-header\\\">\\n    <div class=\\\"row\\\">\\n        <div class=\\\"col s3\\\">\\n            <a class=\\\"back-link\\\" (click)=\\\"back()\\\">\\n                <i class=\\\"material-icons md-18\\\">navigate_before</i>\\n                Back to list\\n            </a>\\n        </div>\\n    </div>\\n    <div class=\\\"row\\\">\\n        <div class=\\\"col s7\\\">\\n            <h1>New scenario</h1>\\n        </div>\\n        <div class=\\\"col s5\\\">\\n            <a [routerLink]=\\\"['../editor-create']\\\" class=\\\"nav-link right\\\">\\n                <i class=\\\"material-icons\\\">edit</i>\\n                Go to Editor\\n            </a>\\n        </div>\\n    </div>\\n</div>\\n\\n<form class=\\\"scenario-details\\\"\\n        (ngSubmit)=\\\"save(scenario)\\\"\\n        #createScenarioWizardForm=\\\"ngForm\\\">\\n    <sh-scenario-wizard\\n        *ngIf=\\\"scenario && scenario.wizard\\\"\\n        [scenario]=\\\"scenario\\\"\\n        (onAddCriteria)=\\\"onAddCriteria()\\\"\\n        (onRemoveCriteria)=\\\"onRemoveCriteria($event)\\\"\\n        (onAddAction)=\\\"onAddAction()\\\"\\n        (onRemoveAction)=\\\"onRemoveAction($event)\\\">\\n    </sh-scenario-wizard>\\n\\n    <button class=\\\"waves-effect waves-light btn blue-grey darken-1\\\"\\n            type=\\\"submit\\\"\\n            [disabled]=\\\"!createScenarioWizardForm.valid\\\">\\n        SAVE SCENARIO\\n    </button>\\n</form>\\n\"\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./app/scenarios/scenario-details/wizard/create-scenario-wizard/create-scenario-wizard.template.html\n// module id = 576\n// module chunks = 4","import { Component, OnInit, ViewContainerRef } from '@angular/core';\nimport { ActivatedRoute, Router } from '@angular/router';\n\nimport { DevicesService } from '../../../../devices/devices.service';\n\nimport { ScenarioService } from '../../../shared/scenario.service';\nimport { CreateScenarioWizardComponent } from '../create-scenario-wizard/create-scenario-wizard.component';\n\nimport { Condition } from '../scenario-entities/condition';\nimport { Action } from '../scenario-entities/action';\nimport { Scenario } from '../scenario-entities/scenario';\n\nimport { Observable } from 'rxjs/Rx';\nimport { DialogService } from '../../../../shared/dialog/dialog.service';\n\n@Component({\n    template: require('./edit-scenario-wizard.template.html')\n})\nexport class EditScenarioWizardComponent extends CreateScenarioWizardComponent implements OnInit {\n\n    constructor(\n        protected _scenarioService: ScenarioService,\n        protected _route: ActivatedRoute,\n        protected _router: Router,\n        protected dialogService: DialogService,\n        protected viewContainerRef: ViewContainerRef,\n        protected devicesService: DevicesService\n    ) {\n        super(_scenarioService, _route, _router, devicesService);\n    }\n\n    ngOnInit() {\n        const deviceListStream = this.devicesService.getSensors();\n        const scenarioStream = this._scenarioService.get(this._route.snapshot.params['id']);\n        const source = Observable.forkJoin(\n            deviceListStream, scenarioStream\n        );\n\n        source.subscribe(result => {\n            const devices = result[0];\n            const scenario = result[1];\n\n            this.devices = devices;\n\n            scenario.wizard = {\n                logicalOperator: scenario.wizard && scenario.wizard.logicalOperator,\n                conditions: mapConditions(this.devices, scenario.wizard.conditions),\n                actions: mapActions(this.devices, scenario.wizard.actions)\n            };\n            this.scenario = new Scenario(scenario);\n        });\n\n        function mapConditions(devices, conditions) {\n            return conditions.map((condition) => new Condition(devices, condition));\n        }\n\n        function mapActions(devices, actions) {\n            return actions.map(action => new Action(devices, action));\n        }\n    }\n\n    save(scenario) {\n        this._scenarioService.update(scenario, true)\n            .subscribe(() => {\n                this.back();\n            });\n    }\n\n    delete(scenario) {\n        const confirmOptions = {\n            title: '',\n            message: 'Are you sure you want to delete this scenario?'\n        };\n\n        this.dialogService.confirm(this.viewContainerRef, confirmOptions)\n            .filter(isConfirmed => isConfirmed)\n            .subscribe(() => {\n                this._scenarioService\n                    .delete(scenario)\n                    .subscribe(data => {\n                        this.back();\n                    });\n            });\n    }\n}\n\n\n\n// WEBPACK FOOTER //\n// ../~/angular2-template-loader!./app/scenarios/scenario-details/wizard/edit-scenario-wizard/edit-scenario-wizard.component.ts","module.exports = \"<div class=\\\"page-header\\\">\\n    <div class=\\\"row\\\">\\n        <div class=\\\"col s3\\\">\\n            <a class=\\\"back-link\\\" (click)=\\\"back()\\\">\\n                <i class=\\\"material-icons md-18\\\">navigate_before</i>\\n                Back to list\\n            </a>\\n        </div>\\n    </div>\\n</div>\\n\\n<form class=\\\"scenario-details\\\"\\n        (ngSubmit)=\\\"save(scenario)\\\"\\n        #editScenarioWizardForm=\\\"ngForm\\\">\\n    <sh-scenario-wizard\\n        *ngIf=\\\"scenario && scenario.wizard\\\"\\n        [scenario]=\\\"scenario\\\"\\n        (onAddCriteria)=\\\"onAddCriteria()\\\"\\n        (onRemoveCriteria)=\\\"onRemoveCriteria()\\\"\\n        (onAddAction)=\\\"onAddAction()\\\"\\n        (onRemoveAction)=\\\"onRemoveAction()\\\">\\n    </sh-scenario-wizard>\\n\\n    <button class=\\\"waves-effect waves-light btn blue-grey darken-1\\\"\\n            type=\\\"submit\\\"\\n            [disabled]=\\\"!editScenarioWizardForm.valid\\\">\\n        SAVE SCENARIO\\n    </button>\\n    <button (click)=\\\"delete(scenario)\\\"\\n            type=\\\"button\\\"\\n            class=\\\"waves-effect waves-light btn blue-grey darken-1\\\">\\n        Remove SCENARIO\\n    </button>\\n</form>\\n\"\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./app/scenarios/scenario-details/wizard/edit-scenario-wizard/edit-scenario-wizard.template.html\n// module id = 578\n// module chunks = 4","import { Component, ViewContainerRef } from '@angular/core';\nimport { Router, ActivatedRoute } from '@angular/router';\n\nimport { ScenarioService } from './../shared/scenario.service';\nimport { ScenarioStatusService } from './scenario-status.service';\nimport { DialogService } from '../../shared/dialog/dialog.service';\n\nconst headersForDisplay = [\n    { topic: 'name', name: 'Name', sortable: true },\n    { topic: 'status', name: 'Status', sortable: false }\n];\nexport const SCENARIO_ACTIVE_STATE = 'active';\nexport const SCENARIO_PAUSED_STATE = 'paused';\n\n@Component({\n    selector: 'sh-scenario-list',\n    template: require('./scenario-list.template.html'),\n    styles: [require('./scenario-list.style.scss')]\n})\nexport class ScenarioListComponent {\n    private scenarioList = [];\n    private _headers = [];\n    private subscription;\n\n    constructor(protected scenarioService: ScenarioService,\n                protected router: Router,\n                protected scenarioStatusService: ScenarioStatusService,\n                protected route: ActivatedRoute,\n                private dialogService: DialogService,\n                private viewContainerRef: ViewContainerRef\n    ) {\n        this._headers = headersForDisplay;\n    }\n\n    ngOnInit() {\n        this.route.data.subscribe(data => {\n            this.scenarioList = data['scenarioList'].map(this.convertScenarioStatus);\n        });\n\n        this.subscription = this.scenarioStatusService['stream'].subscribe((event) =>\n            this.onScenarioStatusChange(event));\n    }\n\n    onScenarioStatusChange(event) {\n        const scenarioToChange = this.scenarioList.find((scenario) => scenario.id === event.id);\n        if (scenarioToChange) {\n            scenarioToChange.active = event.active;\n            this.convertScenarioStatus(scenarioToChange);\n        }\n    }\n\n    ngOnDestroy() {\n        this.subscription.unsubscribe();\n    }\n\n    get headers() {\n        return this._headers;\n    }\n\n    removeScenario(item) {\n        const confirmOptions = {\n            title: '',\n            message: 'Are you sure you want to delete this scenario?'\n        };\n\n        this.dialogService.confirm(this.viewContainerRef, confirmOptions)\n            .filter(isConfirmed => isConfirmed)\n            .subscribe(() => {\n                this.scenarioService\n                    .delete(item)\n                    .subscribe(data => {\n                        this.scenarioList = this.scenarioList\n                            .filter(elem => elem.id !== data.id);\n                    });\n            });\n    }\n\n    toggleScenarioState(scenario) {\n        const active = !scenario.active;\n        const scenarioForUpdate = Object.assign({}, scenario, {active});\n        this.scenarioService\n            .update(scenarioForUpdate)\n            .subscribe(() => {\n                Object.assign(scenario, {\n                    active: !scenario.active\n                });\n                this.convertScenarioStatus(scenario);\n            });\n    }\n\n    navigateToEditView(scenario) {\n        const route = scenario.isConvertable\n            ? 'scenarios/wizard'\n            : 'scenarios/editor';\n        this.router.navigate([route, scenario.id]);\n    }\n\n    convertScenarioStatus(scenario) {\n        return Object.assign(scenario, {\n            status: scenario.active ? SCENARIO_ACTIVE_STATE : SCENARIO_PAUSED_STATE\n        });\n    }\n}\n\n\n\n// WEBPACK FOOTER //\n// ../~/angular2-template-loader!./app/scenarios/scenarios-list/scenario-list.component.ts","import { Injectable } from '@angular/core';\n\nimport * as io from 'socket.io-client';\nimport { Observable } from 'rxjs/Rx';\n\nexport const SCENARIO_STATUS_CHANGE_EVENT = 'scenario-status-change';\n\n@Injectable()\nexport class ScenarioStatusService {\n\n    private stream: Observable<Object>;\n    private io: SocketIOClientStatic;\n\n    constructor() {\n\n        this.io = io;\n        this.setup();\n\n    }\n\n    setup() {\n        const socket = this.io.connect(ENV_PUBLIC_CONFIG.backEndWebSocketUrl);\n        this.stream = Observable.create(observer => {\n            socket.on(SCENARIO_STATUS_CHANGE_EVENT, (value) => observer.next(value));\n        });\n    }\n}\n\n\n\n// WEBPACK FOOTER //\n// ../~/angular2-template-loader!./app/scenarios/scenarios-list/scenario-status.service.ts","module.exports = \"<div class=\\\"sub-header row\\\">\\n  <div id=\\\"page-title\\\" class=\\\"col s5 sub-header__title\\\"><h2>Scenarios</h2></div>\\n  <div class=\\\"sub-header__actions col s4 right\\\">\\n    <button [routerLink]=\\\"['editor-create']\\\"\\n        class=\\\"waves-effect waves-light btn blue-grey darken-1 sub-header__actions__create\\\">Create new scenario</button>\\n  </div>\\n</div>\\n\\n<div *ngIf=\\\"scenarioList.length === 0\\\" class=\\\"empty-list\\\">\\n    <div class=\\\"container empty-list__container\\\">\\n        <div class=\\\"empty-list__container__text\\\">\\n            <h3 class=\\\"empty-list__container__text__main\\\">There are no scenarios yet</h3>\\n            <h4 class=\\\"empty-list__container__text__additional\\\">Scenarios make your home truly intelligent. Go ahead and create your first scenario.</h4>\\n        </div>\\n    </div>\\n</div>\\n\\n<div *ngIf=\\\"scenarioList.length !== 0\\\" class=\\\"scenario-list\\\">\\n    <table class=\\\"highlight responsive-table scenario-list-table\\\">\\n        <thead class=\\\"scenario-list-table__head\\\">\\n            <th *ngFor=\\\"let header of headers\\\"\\n                class=\\\"scenario-list-table__head__item\\\"\\n                [class.sortable]=\\\"header.sortable\\\">\\n                {{ header.name }}\\n                <div [class]=\\\"reverse ? 'up' : 'down'\\\"></div>\\n            </th>\\n            <th class=\\\"scenario-list-table__head__item\\\">\\n                Actions\\n            </th>\\n        </thead>\\n        <tbody class=\\\"scenario-list-table__body\\\">\\n            <tr *ngFor=\\\"let scenario of scenarioList\\\"\\n                (click)=\\\"navigateToEditView(scenario)\\\"\\n                class=\\\"scenario-list-table__body__row\\\">\\n                <td class=\\\"scenario-list-table__body__row__item\\\">\\n                    <span>{{scenario.name}}</span>\\n                </td>\\n                <td class=\\\"scenario-list-table__body__row__item status\\\">\\n                    <span [class]=\\\"scenario.active ? 'active' : 'paused'\\\">{{scenario.status}}</span>\\n                </td>\\n                <td class=\\\"scenario-list-table__body__row__actions\\\">\\n                    <button (click)=\\\"removeScenario(scenario); $event.stopPropagation()\\\"\\n                            class=\\\"waves-effect waves-light btn scenario-list-table__body__row__actions__remove\\\"\\n                            name=\\\"remove-scenario\\\"\\n                            type=\\\"remove\\\">\\n                        <i class=\\\"material-icons scenario-list-table__body__row__actions__remove__icon\\\">delete</i>\\n                    </button>\\n                    <button (click)=\\\"toggleScenarioState(scenario); $event.stopPropagation()\\\"\\n                            class=\\\"waves-effect waves-light btn scenario-list-table__body__row__actions__toggle-state\\\"\\n                            name=\\\"toggle-scenario-state\\\">\\n                        <i class=\\\"material-icons scenario-list-table__body__row__actions__remove__icon\\\">{{ scenario.active ? 'stop' : 'play_arrow' }}</i>\\n                    </button>\\n                </td>\\n            </tr>\\n        </tbody>\\n    </table>\\n</div>\\n\"\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./app/scenarios/scenarios-list/scenario-list.template.html\n// module id = 581\n// module chunks = 4","module.exports = \".sub-header__actions{vertical-align:middle;line-height:54px}.sub-header__actions__create{width:250px}.empty-list__container{padding:0px}.empty-list__container::before{content:'';display:block;background:url(\\\"./assets/empty-scenarios-list.png\\\") no-repeat;background-size:150px;background-position:calc(100% / 2);height:150px;margin:0 6px 0 0}.empty-list__container__text__main{font-family:Roboto-Regular;font-size:24px;text-align:center}.empty-list__container__text__additional{font-family:Roboto-Regular;font-size:15px;text-align:center}.scenario-list-table__body__row{cursor:pointer}.scenario-list-table__body__row__actions{width:150px}.scenario-list-table__body__row__actions__remove{padding:0 15px}.scenario-list-table__body__row__actions__toggle-state{padding:0 15px}.scenario-list-table__body__row .status span{padding:5px;border-radius:2px}.scenario-list-table__body__row .status span.paused{background:#ffa726}.scenario-list-table__body__row .status span.active{background:#26a69a}\\n\"\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./app/scenarios/scenarios-list/scenario-list.style.scss\n// module id = 582\n// module chunks = 4","import { Injectable } from '@angular/core';\nimport { ScenarioService } from '../shared/scenario.service';\n\n@Injectable()\nexport class ScenarioListResolveService {\n    constructor(private scenarioService: ScenarioService) {}\n\n    resolve() {\n        return this.scenarioService.get();\n    }\n}\n\n\n\n// WEBPACK FOOTER //\n// ../~/angular2-template-loader!./app/scenarios/scenarios-list/scenario-list.resolve.service.ts","import { ScenarioDetailsComponent } from './scenario-details/scenario-details.component';\nimport {\n    CreateScenarioEditorComponent\n} from './scenario-details/editor/create-scenario-editor/create-scenario-editor.component';\nimport {\n    EditScenarioEditorComponent\n} from './scenario-details/editor/edit-scenario-editor/edit-scenario-editor.component';\nimport {\n    ScenarioEditorComponent\n} from './scenario-details/editor/scenario-editor/scenario-editor.component';\nimport {\n    CreateScenarioWizardComponent\n} from './scenario-details/wizard/create-scenario-wizard/create-scenario-wizard.component';\nimport {\n    EditScenarioWizardComponent\n} from './scenario-details/wizard/edit-scenario-wizard/edit-scenario-wizard.component';\nimport {\n    ScenarioWizardComponent\n} from './scenario-details/wizard/scenario-wizard/scenario-wizard.component';\nimport { ScenarioListComponent } from './scenarios-list/scenario-list.component';\n\nexport default [\n    ScenarioDetailsComponent,\n    CreateScenarioEditorComponent,\n    EditScenarioEditorComponent,\n    ScenarioEditorComponent,\n    CreateScenarioWizardComponent,\n    EditScenarioWizardComponent,\n    ScenarioWizardComponent,\n    ScenarioListComponent\n];\n\n\n\n// WEBPACK FOOTER //\n// ../~/angular2-template-loader!./app/scenarios/scenarios.declarations.ts","import { Component, ViewChild, EventEmitter, Output, Input } from '@angular/core';\n\nrequire('codemirror/lib/codemirror.css');\nrequire('codemirror/theme/lesser-dark.css');\n\nimport * as CodeMirror from 'codemirror';\nimport 'codemirror/addon/edit/matchbrackets';\nimport 'codemirror/addon/edit/closebrackets';\nimport 'codemirror/mode/javascript/javascript';\n\nimport CODE_MIRROR_EVENTS from './code-mirror-events.const';\n\n@Component({\n    selector: 'sh-scenario-editor',\n    template: '<div #codeEditor></div>'\n})\nexport class ScenarioEditorComponent {\n\n    @ViewChild('codeEditor') codeEditorElement;\n    @Input() scenario: string;\n    @Output() updateScenario = new EventEmitter();\n\n    private codeMirror: Function;\n    private codeEditor: CodeMirror.Editor;\n\n    constructor() {\n        this.codeMirror = CodeMirror;\n    }\n\n    ngAfterViewInit() {\n        this.initCodeEditor();\n    }\n\n    ngOnChanges() {\n        if (this.codeEditor && this.scenario !== this.codeEditor.getValue()) {\n            this.codeEditor.setValue(this.scenario);\n        }\n    }\n\n    initCodeEditor() {\n        this.codeEditor = this.codeMirror(\n            this.codeEditorElement.nativeElement,\n            {\n                mode: 'javascript',\n                lineNumbers: true,\n                autoCloseBrackets: true,\n                matchBrackets: true,\n                tabSize: 4,\n                theme: 'lesser-dark'\n            }\n        );\n\n        this.initListeners();\n    }\n\n    initListeners() {\n        this.codeEditor.on('change', (codeMirror, changeObj) => {\n            if (changeObj.origin !== CODE_MIRROR_EVENTS.SET_VALUE_EVENT) {\n                const scenarioBody = this.codeEditor.getValue();\n                this.updateScenario.emit({scenarioBody});\n            }\n        });\n    }\n}\n\n\n\n// WEBPACK FOOTER //\n// ../~/angular2-template-loader!./app/scenarios/scenario-details/editor/scenario-editor/scenario-editor.component.ts","// style-loader: Adds some css to the DOM by adding a <style> tag\n\n// load the styles\nvar content = require(\"!!../../css-loader/index.js!./codemirror.css\");\nif(typeof content === 'string') content = [[module.id, content, '']];\n// add the styles to the DOM\nvar update = require(\"!../../style-loader/addStyles.js\")(content, {});\nif(content.locals) module.exports = content.locals;\n// Hot Module Replacement\nif(module.hot) {\n\t// When the styles change, update the <style> tags\n\tif(!content.locals) {\n\t\tmodule.hot.accept(\"!!../../css-loader/index.js!./codemirror.css\", function() {\n\t\t\tvar newContent = require(\"!!../../css-loader/index.js!./codemirror.css\");\n\t\t\tif(typeof newContent === 'string') newContent = [[module.id, newContent, '']];\n\t\t\tupdate(newContent);\n\t\t});\n\t}\n\t// When the module is disposed, remove the <style> tags\n\tmodule.hot.dispose(function() { update(); });\n}\n\n\n//////////////////\n// WEBPACK FOOTER\n// ../~/codemirror/lib/codemirror.css\n// module id = 586\n// module chunks = 4","exports = module.exports = require(\"../../css-loader/lib/css-base.js\")();\n// imports\n\n\n// module\nexports.push([module.id, \".CodeMirror{font-family:monospace;height:300px;color:#000}.CodeMirror-lines{padding:4px 0}.CodeMirror pre{padding:0 4px}.CodeMirror-gutter-filler,.CodeMirror-scrollbar-filler{background-color:#fff}.CodeMirror-gutters{border-right:1px solid #ddd;background-color:#f7f7f7;white-space:nowrap}.CodeMirror-linenumber{padding:0 3px 0 5px;min-width:20px;text-align:right;color:#999;white-space:nowrap}.CodeMirror-guttermarker{color:#000}.CodeMirror-guttermarker-subtle{color:#999}.CodeMirror-cursor{border-left:1px solid #000;border-right:none;width:0}.CodeMirror div.CodeMirror-secondarycursor{border-left:1px solid silver}.cm-fat-cursor .CodeMirror-cursor{width:auto;border:0!important;background:#7e7}.cm-fat-cursor div.CodeMirror-cursors{z-index:1}.cm-animate-fat-cursor{width:auto;border:0;-webkit-animation:blink 1.06s steps(1) infinite;animation:blink 1.06s steps(1) infinite;background-color:#7e7}@-webkit-keyframes blink{50%{background-color:transparent}}@keyframes blink{50%{background-color:transparent}}.cm-tab{display:inline-block;text-decoration:inherit}.CodeMirror-rulers{position:absolute;left:0;right:0;top:-50px;bottom:-20px;overflow:hidden}.CodeMirror-ruler{border-left:1px solid #ccc;top:0;bottom:0;position:absolute}.cm-s-default .cm-header{color:blue}.cm-s-default .cm-quote{color:#090}.cm-negative{color:#d44}.cm-positive{color:#292}.cm-header,.cm-strong{font-weight:700}.cm-em{font-style:italic}.cm-link{text-decoration:underline}.cm-strikethrough{text-decoration:line-through}.cm-s-default .cm-keyword{color:#708}.cm-s-default .cm-atom{color:#219}.cm-s-default .cm-number{color:#164}.cm-s-default .cm-def{color:#00f}.cm-s-default .cm-variable-2{color:#05a}.cm-s-default .cm-variable-3{color:#085}.cm-s-default .cm-comment{color:#a50}.cm-s-default .cm-string{color:#a11}.cm-s-default .cm-string-2{color:#f50}.cm-s-default .cm-meta,.cm-s-default .cm-qualifier{color:#555}.cm-s-default .cm-builtin{color:#30a}.cm-s-default .cm-bracket{color:#997}.cm-s-default .cm-tag{color:#170}.cm-s-default .cm-attribute{color:#00c}.cm-s-default .cm-hr{color:#999}.cm-s-default .cm-link{color:#00c}.cm-invalidchar,.cm-s-default .cm-error{color:red}.CodeMirror-composing{border-bottom:2px solid}div.CodeMirror span.CodeMirror-matchingbracket{color:#0f0}div.CodeMirror span.CodeMirror-nonmatchingbracket{color:#f22}.CodeMirror-matchingtag{background:rgba(255,150,0,.3)}.CodeMirror-activeline-background{background:#e8f2ff}.CodeMirror{position:relative;overflow:hidden;background:#fff}.CodeMirror-scroll{overflow:scroll!important;margin-bottom:-30px;margin-right:-30px;padding-bottom:30px;height:100%;outline:none;position:relative}.CodeMirror-sizer{position:relative;border-right:30px solid transparent}.CodeMirror-gutter-filler,.CodeMirror-hscrollbar,.CodeMirror-scrollbar-filler,.CodeMirror-vscrollbar{position:absolute;z-index:6;display:none}.CodeMirror-vscrollbar{right:0;top:0;overflow-x:hidden;overflow-y:scroll}.CodeMirror-hscrollbar{bottom:0;left:0;overflow-y:hidden;overflow-x:scroll}.CodeMirror-scrollbar-filler{right:0;bottom:0}.CodeMirror-gutter-filler{left:0;bottom:0}.CodeMirror-gutters{position:absolute;left:0;top:0;min-height:100%;z-index:3}.CodeMirror-gutter{white-space:normal;height:100%;display:inline-block;vertical-align:top;margin-bottom:-30px}.CodeMirror-gutter-wrapper{position:absolute;z-index:4;background:none!important;border:none!important}.CodeMirror-gutter-background{position:absolute;top:0;bottom:0;z-index:4}.CodeMirror-gutter-elt{position:absolute;cursor:default;z-index:4}.CodeMirror-gutter-wrapper{-webkit-user-select:none;-moz-user-select:none;user-select:none}.CodeMirror-lines{cursor:text;min-height:1px}.CodeMirror pre{border-radius:0;border-width:0;background:transparent;font-family:inherit;font-size:inherit;margin:0;white-space:pre;word-wrap:normal;line-height:inherit;color:inherit;z-index:2;position:relative;overflow:visible;-webkit-tap-highlight-color:transparent;-webkit-font-variant-ligatures:contextual;font-variant-ligatures:contextual}.CodeMirror-wrap pre{word-wrap:break-word;white-space:pre-wrap;word-break:normal}.CodeMirror-linebackground{position:absolute;left:0;right:0;top:0;bottom:0;z-index:0}.CodeMirror-linewidget{position:relative;z-index:2;overflow:auto}.CodeMirror-code{outline:none}.CodeMirror-gutter,.CodeMirror-gutters,.CodeMirror-linenumber,.CodeMirror-scroll,.CodeMirror-sizer{box-sizing:content-box}.CodeMirror-measure{position:absolute;width:100%;height:0;overflow:hidden;visibility:hidden}.CodeMirror-cursor{position:absolute;pointer-events:none}.CodeMirror-measure pre{position:static}div.CodeMirror-cursors{visibility:hidden;position:relative;z-index:3}.CodeMirror-focused div.CodeMirror-cursors,div.CodeMirror-dragcursors{visibility:visible}.CodeMirror-selected{background:#d9d9d9}.CodeMirror-focused .CodeMirror-selected{background:#d7d4f0}.CodeMirror-crosshair{cursor:crosshair}.CodeMirror-line::selection,.CodeMirror-line>span::selection,.CodeMirror-line>span>span::selection{background:#d7d4f0}.CodeMirror-line::-moz-selection,.CodeMirror-line>span::-moz-selection,.CodeMirror-line>span>span::-moz-selection{background:#d7d4f0}.cm-searching{background:#ffa;background:rgba(255,255,0,.4)}.cm-force-border{padding-right:.1px}@media print{.CodeMirror div.CodeMirror-cursors{visibility:hidden}}.cm-tab-wrap-hack:after{content:\\\"\\\"}span.CodeMirror-selectedtext{background:none}\", \"\"]);\n\n// exports\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ../~/css-loader!../~/codemirror/lib/codemirror.css\n// module id = 587\n// module chunks = 4","/*\r\n\tMIT License http://www.opensource.org/licenses/mit-license.php\r\n\tAuthor Tobias Koppers @sokra\r\n*/\r\n// css base code, injected by the css-loader\r\nmodule.exports = function() {\r\n\tvar list = [];\r\n\r\n\t// return the list of modules as css string\r\n\tlist.toString = function toString() {\r\n\t\tvar result = [];\r\n\t\tfor(var i = 0; i < this.length; i++) {\r\n\t\t\tvar item = this[i];\r\n\t\t\tif(item[2]) {\r\n\t\t\t\tresult.push(\"@media \" + item[2] + \"{\" + item[1] + \"}\");\r\n\t\t\t} else {\r\n\t\t\t\tresult.push(item[1]);\r\n\t\t\t}\r\n\t\t}\r\n\t\treturn result.join(\"\");\r\n\t};\r\n\r\n\t// import a list of modules into the list\r\n\tlist.i = function(modules, mediaQuery) {\r\n\t\tif(typeof modules === \"string\")\r\n\t\t\tmodules = [[null, modules, \"\"]];\r\n\t\tvar alreadyImportedModules = {};\r\n\t\tfor(var i = 0; i < this.length; i++) {\r\n\t\t\tvar id = this[i][0];\r\n\t\t\tif(typeof id === \"number\")\r\n\t\t\t\talreadyImportedModules[id] = true;\r\n\t\t}\r\n\t\tfor(i = 0; i < modules.length; i++) {\r\n\t\t\tvar item = modules[i];\r\n\t\t\t// skip already imported module\r\n\t\t\t// this implementation is not 100% perfect for weird media query combinations\r\n\t\t\t//  when a module is imported multiple times with different media queries.\r\n\t\t\t//  I hope this will never occur (Hey this way we have smaller bundles)\r\n\t\t\tif(typeof item[0] !== \"number\" || !alreadyImportedModules[item[0]]) {\r\n\t\t\t\tif(mediaQuery && !item[2]) {\r\n\t\t\t\t\titem[2] = mediaQuery;\r\n\t\t\t\t} else if(mediaQuery) {\r\n\t\t\t\t\titem[2] = \"(\" + item[2] + \") and (\" + mediaQuery + \")\";\r\n\t\t\t\t}\r\n\t\t\t\tlist.push(item);\r\n\t\t\t}\r\n\t\t}\r\n\t};\r\n\treturn list;\r\n};\r\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ../~/css-loader/lib/css-base.js\n// module id = 588\n// module chunks = 4","/*\r\n\tMIT License http://www.opensource.org/licenses/mit-license.php\r\n\tAuthor Tobias Koppers @sokra\r\n*/\r\nvar stylesInDom = {},\r\n\tmemoize = function(fn) {\r\n\t\tvar memo;\r\n\t\treturn function () {\r\n\t\t\tif (typeof memo === \"undefined\") memo = fn.apply(this, arguments);\r\n\t\t\treturn memo;\r\n\t\t};\r\n\t},\r\n\tisOldIE = memoize(function() {\r\n\t\treturn /msie [6-9]\\b/.test(window.navigator.userAgent.toLowerCase());\r\n\t}),\r\n\tgetHeadElement = memoize(function () {\r\n\t\treturn document.head || document.getElementsByTagName(\"head\")[0];\r\n\t}),\r\n\tsingletonElement = null,\r\n\tsingletonCounter = 0,\r\n\tstyleElementsInsertedAtTop = [];\r\n\r\nmodule.exports = function(list, options) {\r\n\tif(typeof DEBUG !== \"undefined\" && DEBUG) {\r\n\t\tif(typeof document !== \"object\") throw new Error(\"The style-loader cannot be used in a non-browser environment\");\r\n\t}\r\n\r\n\toptions = options || {};\r\n\t// Force single-tag solution on IE6-9, which has a hard limit on the # of <style>\r\n\t// tags it will allow on a page\r\n\tif (typeof options.singleton === \"undefined\") options.singleton = isOldIE();\r\n\r\n\t// By default, add <style> tags to the bottom of <head>.\r\n\tif (typeof options.insertAt === \"undefined\") options.insertAt = \"bottom\";\r\n\r\n\tvar styles = listToStyles(list);\r\n\taddStylesToDom(styles, options);\r\n\r\n\treturn function update(newList) {\r\n\t\tvar mayRemove = [];\r\n\t\tfor(var i = 0; i < styles.length; i++) {\r\n\t\t\tvar item = styles[i];\r\n\t\t\tvar domStyle = stylesInDom[item.id];\r\n\t\t\tdomStyle.refs--;\r\n\t\t\tmayRemove.push(domStyle);\r\n\t\t}\r\n\t\tif(newList) {\r\n\t\t\tvar newStyles = listToStyles(newList);\r\n\t\t\taddStylesToDom(newStyles, options);\r\n\t\t}\r\n\t\tfor(var i = 0; i < mayRemove.length; i++) {\r\n\t\t\tvar domStyle = mayRemove[i];\r\n\t\t\tif(domStyle.refs === 0) {\r\n\t\t\t\tfor(var j = 0; j < domStyle.parts.length; j++)\r\n\t\t\t\t\tdomStyle.parts[j]();\r\n\t\t\t\tdelete stylesInDom[domStyle.id];\r\n\t\t\t}\r\n\t\t}\r\n\t};\r\n}\r\n\r\nfunction addStylesToDom(styles, options) {\r\n\tfor(var i = 0; i < styles.length; i++) {\r\n\t\tvar item = styles[i];\r\n\t\tvar domStyle = stylesInDom[item.id];\r\n\t\tif(domStyle) {\r\n\t\t\tdomStyle.refs++;\r\n\t\t\tfor(var j = 0; j < domStyle.parts.length; j++) {\r\n\t\t\t\tdomStyle.parts[j](item.parts[j]);\r\n\t\t\t}\r\n\t\t\tfor(; j < item.parts.length; j++) {\r\n\t\t\t\tdomStyle.parts.push(addStyle(item.parts[j], options));\r\n\t\t\t}\r\n\t\t} else {\r\n\t\t\tvar parts = [];\r\n\t\t\tfor(var j = 0; j < item.parts.length; j++) {\r\n\t\t\t\tparts.push(addStyle(item.parts[j], options));\r\n\t\t\t}\r\n\t\t\tstylesInDom[item.id] = {id: item.id, refs: 1, parts: parts};\r\n\t\t}\r\n\t}\r\n}\r\n\r\nfunction listToStyles(list) {\r\n\tvar styles = [];\r\n\tvar newStyles = {};\r\n\tfor(var i = 0; i < list.length; i++) {\r\n\t\tvar item = list[i];\r\n\t\tvar id = item[0];\r\n\t\tvar css = item[1];\r\n\t\tvar media = item[2];\r\n\t\tvar sourceMap = item[3];\r\n\t\tvar part = {css: css, media: media, sourceMap: sourceMap};\r\n\t\tif(!newStyles[id])\r\n\t\t\tstyles.push(newStyles[id] = {id: id, parts: [part]});\r\n\t\telse\r\n\t\t\tnewStyles[id].parts.push(part);\r\n\t}\r\n\treturn styles;\r\n}\r\n\r\nfunction insertStyleElement(options, styleElement) {\r\n\tvar head = getHeadElement();\r\n\tvar lastStyleElementInsertedAtTop = styleElementsInsertedAtTop[styleElementsInsertedAtTop.length - 1];\r\n\tif (options.insertAt === \"top\") {\r\n\t\tif(!lastStyleElementInsertedAtTop) {\r\n\t\t\thead.insertBefore(styleElement, head.firstChild);\r\n\t\t} else if(lastStyleElementInsertedAtTop.nextSibling) {\r\n\t\t\thead.insertBefore(styleElement, lastStyleElementInsertedAtTop.nextSibling);\r\n\t\t} else {\r\n\t\t\thead.appendChild(styleElement);\r\n\t\t}\r\n\t\tstyleElementsInsertedAtTop.push(styleElement);\r\n\t} else if (options.insertAt === \"bottom\") {\r\n\t\thead.appendChild(styleElement);\r\n\t} else {\r\n\t\tthrow new Error(\"Invalid value for parameter 'insertAt'. Must be 'top' or 'bottom'.\");\r\n\t}\r\n}\r\n\r\nfunction removeStyleElement(styleElement) {\r\n\tstyleElement.parentNode.removeChild(styleElement);\r\n\tvar idx = styleElementsInsertedAtTop.indexOf(styleElement);\r\n\tif(idx >= 0) {\r\n\t\tstyleElementsInsertedAtTop.splice(idx, 1);\r\n\t}\r\n}\r\n\r\nfunction createStyleElement(options) {\r\n\tvar styleElement = document.createElement(\"style\");\r\n\tstyleElement.type = \"text/css\";\r\n\tinsertStyleElement(options, styleElement);\r\n\treturn styleElement;\r\n}\r\n\r\nfunction createLinkElement(options) {\r\n\tvar linkElement = document.createElement(\"link\");\r\n\tlinkElement.rel = \"stylesheet\";\r\n\tinsertStyleElement(options, linkElement);\r\n\treturn linkElement;\r\n}\r\n\r\nfunction addStyle(obj, options) {\r\n\tvar styleElement, update, remove;\r\n\r\n\tif (options.singleton) {\r\n\t\tvar styleIndex = singletonCounter++;\r\n\t\tstyleElement = singletonElement || (singletonElement = createStyleElement(options));\r\n\t\tupdate = applyToSingletonTag.bind(null, styleElement, styleIndex, false);\r\n\t\tremove = applyToSingletonTag.bind(null, styleElement, styleIndex, true);\r\n\t} else if(obj.sourceMap &&\r\n\t\ttypeof URL === \"function\" &&\r\n\t\ttypeof URL.createObjectURL === \"function\" &&\r\n\t\ttypeof URL.revokeObjectURL === \"function\" &&\r\n\t\ttypeof Blob === \"function\" &&\r\n\t\ttypeof btoa === \"function\") {\r\n\t\tstyleElement = createLinkElement(options);\r\n\t\tupdate = updateLink.bind(null, styleElement);\r\n\t\tremove = function() {\r\n\t\t\tremoveStyleElement(styleElement);\r\n\t\t\tif(styleElement.href)\r\n\t\t\t\tURL.revokeObjectURL(styleElement.href);\r\n\t\t};\r\n\t} else {\r\n\t\tstyleElement = createStyleElement(options);\r\n\t\tupdate = applyToTag.bind(null, styleElement);\r\n\t\tremove = function() {\r\n\t\t\tremoveStyleElement(styleElement);\r\n\t\t};\r\n\t}\r\n\r\n\tupdate(obj);\r\n\r\n\treturn function updateStyle(newObj) {\r\n\t\tif(newObj) {\r\n\t\t\tif(newObj.css === obj.css && newObj.media === obj.media && newObj.sourceMap === obj.sourceMap)\r\n\t\t\t\treturn;\r\n\t\t\tupdate(obj = newObj);\r\n\t\t} else {\r\n\t\t\tremove();\r\n\t\t}\r\n\t};\r\n}\r\n\r\nvar replaceText = (function () {\r\n\tvar textStore = [];\r\n\r\n\treturn function (index, replacement) {\r\n\t\ttextStore[index] = replacement;\r\n\t\treturn textStore.filter(Boolean).join('\\n');\r\n\t};\r\n})();\r\n\r\nfunction applyToSingletonTag(styleElement, index, remove, obj) {\r\n\tvar css = remove ? \"\" : obj.css;\r\n\r\n\tif (styleElement.styleSheet) {\r\n\t\tstyleElement.styleSheet.cssText = replaceText(index, css);\r\n\t} else {\r\n\t\tvar cssNode = document.createTextNode(css);\r\n\t\tvar childNodes = styleElement.childNodes;\r\n\t\tif (childNodes[index]) styleElement.removeChild(childNodes[index]);\r\n\t\tif (childNodes.length) {\r\n\t\t\tstyleElement.insertBefore(cssNode, childNodes[index]);\r\n\t\t} else {\r\n\t\t\tstyleElement.appendChild(cssNode);\r\n\t\t}\r\n\t}\r\n}\r\n\r\nfunction applyToTag(styleElement, obj) {\r\n\tvar css = obj.css;\r\n\tvar media = obj.media;\r\n\r\n\tif(media) {\r\n\t\tstyleElement.setAttribute(\"media\", media)\r\n\t}\r\n\r\n\tif(styleElement.styleSheet) {\r\n\t\tstyleElement.styleSheet.cssText = css;\r\n\t} else {\r\n\t\twhile(styleElement.firstChild) {\r\n\t\t\tstyleElement.removeChild(styleElement.firstChild);\r\n\t\t}\r\n\t\tstyleElement.appendChild(document.createTextNode(css));\r\n\t}\r\n}\r\n\r\nfunction updateLink(linkElement, obj) {\r\n\tvar css = obj.css;\r\n\tvar sourceMap = obj.sourceMap;\r\n\r\n\tif(sourceMap) {\r\n\t\t// http://stackoverflow.com/a/26603875\r\n\t\tcss += \"\\n/*# sourceMappingURL=data:application/json;base64,\" + btoa(unescape(encodeURIComponent(JSON.stringify(sourceMap)))) + \" */\";\r\n\t}\r\n\r\n\tvar blob = new Blob([css], { type: \"text/css\" });\r\n\r\n\tvar oldSrc = linkElement.href;\r\n\r\n\tlinkElement.href = URL.createObjectURL(blob);\r\n\r\n\tif(oldSrc)\r\n\t\tURL.revokeObjectURL(oldSrc);\r\n}\r\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ../~/style-loader/addStyles.js\n// module id = 589\n// module chunks = 4","// style-loader: Adds some css to the DOM by adding a <style> tag\n\n// load the styles\nvar content = require(\"!!../../css-loader/index.js!./lesser-dark.css\");\nif(typeof content === 'string') content = [[module.id, content, '']];\n// add the styles to the DOM\nvar update = require(\"!../../style-loader/addStyles.js\")(content, {});\nif(content.locals) module.exports = content.locals;\n// Hot Module Replacement\nif(module.hot) {\n\t// When the styles change, update the <style> tags\n\tif(!content.locals) {\n\t\tmodule.hot.accept(\"!!../../css-loader/index.js!./lesser-dark.css\", function() {\n\t\t\tvar newContent = require(\"!!../../css-loader/index.js!./lesser-dark.css\");\n\t\t\tif(typeof newContent === 'string') newContent = [[module.id, newContent, '']];\n\t\t\tupdate(newContent);\n\t\t});\n\t}\n\t// When the module is disposed, remove the <style> tags\n\tmodule.hot.dispose(function() { update(); });\n}\n\n\n//////////////////\n// WEBPACK FOOTER\n// ../~/codemirror/theme/lesser-dark.css\n// module id = 590\n// module chunks = 4","exports = module.exports = require(\"../../css-loader/lib/css-base.js\")();\n// imports\n\n\n// module\nexports.push([module.id, \".cm-s-lesser-dark{line-height:1.3em}.cm-s-lesser-dark.CodeMirror{background:#262626;color:#ebefe7;text-shadow:0 -1px 1px #262626}.cm-s-lesser-dark div.CodeMirror-selected{background:#45443b}.cm-s-lesser-dark .CodeMirror-line::selection,.cm-s-lesser-dark .CodeMirror-line>span::selection,.cm-s-lesser-dark .CodeMirror-line>span>span::selection{background:rgba(69,68,59,.99)}.cm-s-lesser-dark .CodeMirror-line::-moz-selection,.cm-s-lesser-dark .CodeMirror-line>span::-moz-selection,.cm-s-lesser-dark .CodeMirror-line>span>span::-moz-selection{background:rgba(69,68,59,.99)}.cm-s-lesser-dark .CodeMirror-cursor{border-left:1px solid #fff}.cm-s-lesser-dark pre{padding:0 8px}.cm-s-lesser-dark.CodeMirror span.CodeMirror-matchingbracket{color:#7efc7e}.cm-s-lesser-dark .CodeMirror-gutters{background:#262626;border-right:1px solid #aaa}.cm-s-lesser-dark .CodeMirror-guttermarker{color:#599eff}.cm-s-lesser-dark .CodeMirror-guttermarker-subtle,.cm-s-lesser-dark .CodeMirror-linenumber{color:#777}.cm-s-lesser-dark span.cm-header{color:#a0a}.cm-s-lesser-dark span.cm-quote{color:#090}.cm-s-lesser-dark span.cm-keyword{color:#599eff}.cm-s-lesser-dark span.cm-atom{color:#c2b470}.cm-s-lesser-dark span.cm-number{color:#b35e4d}.cm-s-lesser-dark span.cm-def{color:#fff}.cm-s-lesser-dark span.cm-variable{color:#d9bf8c}.cm-s-lesser-dark span.cm-variable-2{color:#669199}.cm-s-lesser-dark span.cm-variable-3{color:#fff}.cm-s-lesser-dark span.cm-operator,.cm-s-lesser-dark span.cm-property{color:#92a75c}.cm-s-lesser-dark span.cm-comment{color:#666}.cm-s-lesser-dark span.cm-string{color:#bcd279}.cm-s-lesser-dark span.cm-string-2{color:#f50}.cm-s-lesser-dark span.cm-meta{color:#738c73}.cm-s-lesser-dark span.cm-qualifier{color:#555}.cm-s-lesser-dark span.cm-builtin{color:#ff9e59}.cm-s-lesser-dark span.cm-bracket{color:#ebefe7}.cm-s-lesser-dark span.cm-tag{color:#669199}.cm-s-lesser-dark span.cm-attribute{color:#00c}.cm-s-lesser-dark span.cm-hr{color:#999}.cm-s-lesser-dark span.cm-link{color:#00c}.cm-s-lesser-dark span.cm-error{color:#9d1e15}.cm-s-lesser-dark .CodeMirror-activeline-background{background:#3c3a3a}.cm-s-lesser-dark .CodeMirror-matchingbracket{outline:1px solid grey;color:#fff!important}\", \"\"]);\n\n// exports\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ../~/css-loader!../~/codemirror/theme/lesser-dark.css\n// module id = 591\n// module chunks = 4","// CodeMirror, copyright (c) by Marijn Haverbeke and others\n// Distributed under an MIT license: http://codemirror.net/LICENSE\n\n// This is CodeMirror (http://codemirror.net), a code editor\n// implemented in JavaScript on top of the browser's DOM.\n//\n// You can find some technical background for some of the code below\n// at http://marijnhaverbeke.nl/blog/#cm-internals .\n\n(function (global, factory) {\n  typeof exports === 'object' && typeof module !== 'undefined' ? module.exports = factory() :\n  typeof define === 'function' && define.amd ? define(factory) :\n  (global.CodeMirror = factory());\n}(this, (function () { 'use strict';\n\n// Kludges for bugs and behavior differences that can't be feature\n// detected are enabled based on userAgent etc sniffing.\nvar userAgent = navigator.userAgent\nvar platform = navigator.platform\n\nvar gecko = /gecko\\/\\d/i.test(userAgent)\nvar ie_upto10 = /MSIE \\d/.test(userAgent)\nvar ie_11up = /Trident\\/(?:[7-9]|\\d{2,})\\..*rv:(\\d+)/.exec(userAgent)\nvar edge = /Edge\\/(\\d+)/.exec(userAgent)\nvar ie = ie_upto10 || ie_11up || edge\nvar ie_version = ie && (ie_upto10 ? document.documentMode || 6 : +(edge || ie_11up)[1])\nvar webkit = !edge && /WebKit\\//.test(userAgent)\nvar qtwebkit = webkit && /Qt\\/\\d+\\.\\d+/.test(userAgent)\nvar chrome = !edge && /Chrome\\//.test(userAgent)\nvar presto = /Opera\\//.test(userAgent)\nvar safari = /Apple Computer/.test(navigator.vendor)\nvar mac_geMountainLion = /Mac OS X 1\\d\\D([8-9]|\\d\\d)\\D/.test(userAgent)\nvar phantom = /PhantomJS/.test(userAgent)\n\nvar ios = !edge && /AppleWebKit/.test(userAgent) && /Mobile\\/\\w+/.test(userAgent)\n// This is woefully incomplete. Suggestions for alternative methods welcome.\nvar mobile = ios || /Android|webOS|BlackBerry|Opera Mini|Opera Mobi|IEMobile/i.test(userAgent)\nvar mac = ios || /Mac/.test(platform)\nvar chromeOS = /\\bCrOS\\b/.test(userAgent)\nvar windows = /win/i.test(platform)\n\nvar presto_version = presto && userAgent.match(/Version\\/(\\d*\\.\\d*)/)\nif (presto_version) { presto_version = Number(presto_version[1]) }\nif (presto_version && presto_version >= 15) { presto = false; webkit = true }\n// Some browsers use the wrong event properties to signal cmd/ctrl on OS X\nvar flipCtrlCmd = mac && (qtwebkit || presto && (presto_version == null || presto_version < 12.11))\nvar captureRightClick = gecko || (ie && ie_version >= 9)\n\nfunction classTest(cls) { return new RegExp(\"(^|\\\\s)\" + cls + \"(?:$|\\\\s)\\\\s*\") }\n\nvar rmClass = function(node, cls) {\n  var current = node.className\n  var match = classTest(cls).exec(current)\n  if (match) {\n    var after = current.slice(match.index + match[0].length)\n    node.className = current.slice(0, match.index) + (after ? match[1] + after : \"\")\n  }\n}\n\nfunction removeChildren(e) {\n  for (var count = e.childNodes.length; count > 0; --count)\n    { e.removeChild(e.firstChild) }\n  return e\n}\n\nfunction removeChildrenAndAdd(parent, e) {\n  return removeChildren(parent).appendChild(e)\n}\n\nfunction elt(tag, content, className, style) {\n  var e = document.createElement(tag)\n  if (className) { e.className = className }\n  if (style) { e.style.cssText = style }\n  if (typeof content == \"string\") { e.appendChild(document.createTextNode(content)) }\n  else if (content) { for (var i = 0; i < content.length; ++i) { e.appendChild(content[i]) } }\n  return e\n}\n\nvar range\nif (document.createRange) { range = function(node, start, end, endNode) {\n  var r = document.createRange()\n  r.setEnd(endNode || node, end)\n  r.setStart(node, start)\n  return r\n} }\nelse { range = function(node, start, end) {\n  var r = document.body.createTextRange()\n  try { r.moveToElementText(node.parentNode) }\n  catch(e) { return r }\n  r.collapse(true)\n  r.moveEnd(\"character\", end)\n  r.moveStart(\"character\", start)\n  return r\n} }\n\nfunction contains(parent, child) {\n  if (child.nodeType == 3) // Android browser always returns false when child is a textnode\n    { child = child.parentNode }\n  if (parent.contains)\n    { return parent.contains(child) }\n  do {\n    if (child.nodeType == 11) { child = child.host }\n    if (child == parent) { return true }\n  } while (child = child.parentNode)\n}\n\nfunction activeElt() {\n  // IE and Edge may throw an \"Unspecified Error\" when accessing document.activeElement.\n  // IE < 10 will throw when accessed while the page is loading or in an iframe.\n  // IE > 9 and Edge will throw when accessed in an iframe if document.body is unavailable.\n  var activeElement\n  try {\n    activeElement = document.activeElement\n  } catch(e) {\n    activeElement = document.body || null\n  }\n  while (activeElement && activeElement.root && activeElement.root.activeElement)\n    { activeElement = activeElement.root.activeElement }\n  return activeElement\n}\n\nfunction addClass(node, cls) {\n  var current = node.className\n  if (!classTest(cls).test(current)) { node.className += (current ? \" \" : \"\") + cls }\n}\nfunction joinClasses(a, b) {\n  var as = a.split(\" \")\n  for (var i = 0; i < as.length; i++)\n    { if (as[i] && !classTest(as[i]).test(b)) { b += \" \" + as[i] } }\n  return b\n}\n\nvar selectInput = function(node) { node.select() }\nif (ios) // Mobile Safari apparently has a bug where select() is broken.\n  { selectInput = function(node) { node.selectionStart = 0; node.selectionEnd = node.value.length } }\nelse if (ie) // Suppress mysterious IE10 errors\n  { selectInput = function(node) { try { node.select() } catch(_e) {} } }\n\nfunction bind(f) {\n  var args = Array.prototype.slice.call(arguments, 1)\n  return function(){return f.apply(null, args)}\n}\n\nfunction copyObj(obj, target, overwrite) {\n  if (!target) { target = {} }\n  for (var prop in obj)\n    { if (obj.hasOwnProperty(prop) && (overwrite !== false || !target.hasOwnProperty(prop)))\n      { target[prop] = obj[prop] } }\n  return target\n}\n\n// Counts the column offset in a string, taking tabs into account.\n// Used mostly to find indentation.\nfunction countColumn(string, end, tabSize, startIndex, startValue) {\n  if (end == null) {\n    end = string.search(/[^\\s\\u00a0]/)\n    if (end == -1) { end = string.length }\n  }\n  for (var i = startIndex || 0, n = startValue || 0;;) {\n    var nextTab = string.indexOf(\"\\t\", i)\n    if (nextTab < 0 || nextTab >= end)\n      { return n + (end - i) }\n    n += nextTab - i\n    n += tabSize - (n % tabSize)\n    i = nextTab + 1\n  }\n}\n\nvar Delayed = function() {this.id = null};\nDelayed.prototype.set = function (ms, f) {\n  clearTimeout(this.id)\n  this.id = setTimeout(f, ms)\n};\n\nfunction indexOf(array, elt) {\n  for (var i = 0; i < array.length; ++i)\n    { if (array[i] == elt) { return i } }\n  return -1\n}\n\n// Number of pixels added to scroller and sizer to hide scrollbar\nvar scrollerGap = 30\n\n// Returned or thrown by various protocols to signal 'I'm not\n// handling this'.\nvar Pass = {toString: function(){return \"CodeMirror.Pass\"}}\n\n// Reused option objects for setSelection & friends\nvar sel_dontScroll = {scroll: false};\nvar sel_mouse = {origin: \"*mouse\"};\nvar sel_move = {origin: \"+move\"};\n// The inverse of countColumn -- find the offset that corresponds to\n// a particular column.\nfunction findColumn(string, goal, tabSize) {\n  for (var pos = 0, col = 0;;) {\n    var nextTab = string.indexOf(\"\\t\", pos)\n    if (nextTab == -1) { nextTab = string.length }\n    var skipped = nextTab - pos\n    if (nextTab == string.length || col + skipped >= goal)\n      { return pos + Math.min(skipped, goal - col) }\n    col += nextTab - pos\n    col += tabSize - (col % tabSize)\n    pos = nextTab + 1\n    if (col >= goal) { return pos }\n  }\n}\n\nvar spaceStrs = [\"\"]\nfunction spaceStr(n) {\n  while (spaceStrs.length <= n)\n    { spaceStrs.push(lst(spaceStrs) + \" \") }\n  return spaceStrs[n]\n}\n\nfunction lst(arr) { return arr[arr.length-1] }\n\nfunction map(array, f) {\n  var out = []\n  for (var i = 0; i < array.length; i++) { out[i] = f(array[i], i) }\n  return out\n}\n\nfunction insertSorted(array, value, score) {\n  var pos = 0, priority = score(value)\n  while (pos < array.length && score(array[pos]) <= priority) { pos++ }\n  array.splice(pos, 0, value)\n}\n\nfunction nothing() {}\n\nfunction createObj(base, props) {\n  var inst\n  if (Object.create) {\n    inst = Object.create(base)\n  } else {\n    nothing.prototype = base\n    inst = new nothing()\n  }\n  if (props) { copyObj(props, inst) }\n  return inst\n}\n\nvar nonASCIISingleCaseWordChar = /[\\u00df\\u0587\\u0590-\\u05f4\\u0600-\\u06ff\\u3040-\\u309f\\u30a0-\\u30ff\\u3400-\\u4db5\\u4e00-\\u9fcc\\uac00-\\ud7af]/\nfunction isWordCharBasic(ch) {\n  return /\\w/.test(ch) || ch > \"\\x80\" &&\n    (ch.toUpperCase() != ch.toLowerCase() || nonASCIISingleCaseWordChar.test(ch))\n}\nfunction isWordChar(ch, helper) {\n  if (!helper) { return isWordCharBasic(ch) }\n  if (helper.source.indexOf(\"\\\\w\") > -1 && isWordCharBasic(ch)) { return true }\n  return helper.test(ch)\n}\n\nfunction isEmpty(obj) {\n  for (var n in obj) { if (obj.hasOwnProperty(n) && obj[n]) { return false } }\n  return true\n}\n\n// Extending unicode characters. A series of a non-extending char +\n// any number of extending chars is treated as a single unit as far\n// as editing and measuring is concerned. This is not fully correct,\n// since some scripts/fonts/browsers also treat other configurations\n// of code points as a group.\nvar extendingChars = /[\\u0300-\\u036f\\u0483-\\u0489\\u0591-\\u05bd\\u05bf\\u05c1\\u05c2\\u05c4\\u05c5\\u05c7\\u0610-\\u061a\\u064b-\\u065e\\u0670\\u06d6-\\u06dc\\u06de-\\u06e4\\u06e7\\u06e8\\u06ea-\\u06ed\\u0711\\u0730-\\u074a\\u07a6-\\u07b0\\u07eb-\\u07f3\\u0816-\\u0819\\u081b-\\u0823\\u0825-\\u0827\\u0829-\\u082d\\u0900-\\u0902\\u093c\\u0941-\\u0948\\u094d\\u0951-\\u0955\\u0962\\u0963\\u0981\\u09bc\\u09be\\u09c1-\\u09c4\\u09cd\\u09d7\\u09e2\\u09e3\\u0a01\\u0a02\\u0a3c\\u0a41\\u0a42\\u0a47\\u0a48\\u0a4b-\\u0a4d\\u0a51\\u0a70\\u0a71\\u0a75\\u0a81\\u0a82\\u0abc\\u0ac1-\\u0ac5\\u0ac7\\u0ac8\\u0acd\\u0ae2\\u0ae3\\u0b01\\u0b3c\\u0b3e\\u0b3f\\u0b41-\\u0b44\\u0b4d\\u0b56\\u0b57\\u0b62\\u0b63\\u0b82\\u0bbe\\u0bc0\\u0bcd\\u0bd7\\u0c3e-\\u0c40\\u0c46-\\u0c48\\u0c4a-\\u0c4d\\u0c55\\u0c56\\u0c62\\u0c63\\u0cbc\\u0cbf\\u0cc2\\u0cc6\\u0ccc\\u0ccd\\u0cd5\\u0cd6\\u0ce2\\u0ce3\\u0d3e\\u0d41-\\u0d44\\u0d4d\\u0d57\\u0d62\\u0d63\\u0dca\\u0dcf\\u0dd2-\\u0dd4\\u0dd6\\u0ddf\\u0e31\\u0e34-\\u0e3a\\u0e47-\\u0e4e\\u0eb1\\u0eb4-\\u0eb9\\u0ebb\\u0ebc\\u0ec8-\\u0ecd\\u0f18\\u0f19\\u0f35\\u0f37\\u0f39\\u0f71-\\u0f7e\\u0f80-\\u0f84\\u0f86\\u0f87\\u0f90-\\u0f97\\u0f99-\\u0fbc\\u0fc6\\u102d-\\u1030\\u1032-\\u1037\\u1039\\u103a\\u103d\\u103e\\u1058\\u1059\\u105e-\\u1060\\u1071-\\u1074\\u1082\\u1085\\u1086\\u108d\\u109d\\u135f\\u1712-\\u1714\\u1732-\\u1734\\u1752\\u1753\\u1772\\u1773\\u17b7-\\u17bd\\u17c6\\u17c9-\\u17d3\\u17dd\\u180b-\\u180d\\u18a9\\u1920-\\u1922\\u1927\\u1928\\u1932\\u1939-\\u193b\\u1a17\\u1a18\\u1a56\\u1a58-\\u1a5e\\u1a60\\u1a62\\u1a65-\\u1a6c\\u1a73-\\u1a7c\\u1a7f\\u1b00-\\u1b03\\u1b34\\u1b36-\\u1b3a\\u1b3c\\u1b42\\u1b6b-\\u1b73\\u1b80\\u1b81\\u1ba2-\\u1ba5\\u1ba8\\u1ba9\\u1c2c-\\u1c33\\u1c36\\u1c37\\u1cd0-\\u1cd2\\u1cd4-\\u1ce0\\u1ce2-\\u1ce8\\u1ced\\u1dc0-\\u1de6\\u1dfd-\\u1dff\\u200c\\u200d\\u20d0-\\u20f0\\u2cef-\\u2cf1\\u2de0-\\u2dff\\u302a-\\u302f\\u3099\\u309a\\ua66f-\\ua672\\ua67c\\ua67d\\ua6f0\\ua6f1\\ua802\\ua806\\ua80b\\ua825\\ua826\\ua8c4\\ua8e0-\\ua8f1\\ua926-\\ua92d\\ua947-\\ua951\\ua980-\\ua982\\ua9b3\\ua9b6-\\ua9b9\\ua9bc\\uaa29-\\uaa2e\\uaa31\\uaa32\\uaa35\\uaa36\\uaa43\\uaa4c\\uaab0\\uaab2-\\uaab4\\uaab7\\uaab8\\uaabe\\uaabf\\uaac1\\uabe5\\uabe8\\uabed\\udc00-\\udfff\\ufb1e\\ufe00-\\ufe0f\\ufe20-\\ufe26\\uff9e\\uff9f]/\nfunction isExtendingChar(ch) { return ch.charCodeAt(0) >= 768 && extendingChars.test(ch) }\n\n// Returns a number from the range [`0`; `str.length`] unless `pos` is outside that range.\nfunction skipExtendingChars(str, pos, dir) {\n  while ((dir < 0 ? pos > 0 : pos < str.length) && isExtendingChar(str.charAt(pos))) { pos += dir }\n  return pos\n}\n\n// Returns the value from the range [`from`; `to`] that satisfies\n// `pred` and is closest to `from`. Assumes that at least `to` satisfies `pred`.\nfunction findFirst(pred, from, to) {\n  for (;;) {\n    if (Math.abs(from - to) <= 1) { return pred(from) ? from : to }\n    var mid = Math.floor((from + to) / 2)\n    if (pred(mid)) { to = mid }\n    else { from = mid }\n  }\n}\n\n// The display handles the DOM integration, both for input reading\n// and content drawing. It holds references to DOM nodes and\n// display-related state.\n\nfunction Display(place, doc, input) {\n  var d = this\n  this.input = input\n\n  // Covers bottom-right square when both scrollbars are present.\n  d.scrollbarFiller = elt(\"div\", null, \"CodeMirror-scrollbar-filler\")\n  d.scrollbarFiller.setAttribute(\"cm-not-content\", \"true\")\n  // Covers bottom of gutter when coverGutterNextToScrollbar is on\n  // and h scrollbar is present.\n  d.gutterFiller = elt(\"div\", null, \"CodeMirror-gutter-filler\")\n  d.gutterFiller.setAttribute(\"cm-not-content\", \"true\")\n  // Will contain the actual code, positioned to cover the viewport.\n  d.lineDiv = elt(\"div\", null, \"CodeMirror-code\")\n  // Elements are added to these to represent selection and cursors.\n  d.selectionDiv = elt(\"div\", null, null, \"position: relative; z-index: 1\")\n  d.cursorDiv = elt(\"div\", null, \"CodeMirror-cursors\")\n  // A visibility: hidden element used to find the size of things.\n  d.measure = elt(\"div\", null, \"CodeMirror-measure\")\n  // When lines outside of the viewport are measured, they are drawn in this.\n  d.lineMeasure = elt(\"div\", null, \"CodeMirror-measure\")\n  // Wraps everything that needs to exist inside the vertically-padded coordinate system\n  d.lineSpace = elt(\"div\", [d.measure, d.lineMeasure, d.selectionDiv, d.cursorDiv, d.lineDiv],\n                    null, \"position: relative; outline: none\")\n  // Moved around its parent to cover visible view.\n  d.mover = elt(\"div\", [elt(\"div\", [d.lineSpace], \"CodeMirror-lines\")], null, \"position: relative\")\n  // Set to the height of the document, allowing scrolling.\n  d.sizer = elt(\"div\", [d.mover], \"CodeMirror-sizer\")\n  d.sizerWidth = null\n  // Behavior of elts with overflow: auto and padding is\n  // inconsistent across browsers. This is used to ensure the\n  // scrollable area is big enough.\n  d.heightForcer = elt(\"div\", null, null, \"position: absolute; height: \" + scrollerGap + \"px; width: 1px;\")\n  // Will contain the gutters, if any.\n  d.gutters = elt(\"div\", null, \"CodeMirror-gutters\")\n  d.lineGutter = null\n  // Actual scrollable element.\n  d.scroller = elt(\"div\", [d.sizer, d.heightForcer, d.gutters], \"CodeMirror-scroll\")\n  d.scroller.setAttribute(\"tabIndex\", \"-1\")\n  // The element in which the editor lives.\n  d.wrapper = elt(\"div\", [d.scrollbarFiller, d.gutterFiller, d.scroller], \"CodeMirror\")\n\n  // Work around IE7 z-index bug (not perfect, hence IE7 not really being supported)\n  if (ie && ie_version < 8) { d.gutters.style.zIndex = -1; d.scroller.style.paddingRight = 0 }\n  if (!webkit && !(gecko && mobile)) { d.scroller.draggable = true }\n\n  if (place) {\n    if (place.appendChild) { place.appendChild(d.wrapper) }\n    else { place(d.wrapper) }\n  }\n\n  // Current rendered range (may be bigger than the view window).\n  d.viewFrom = d.viewTo = doc.first\n  d.reportedViewFrom = d.reportedViewTo = doc.first\n  // Information about the rendered lines.\n  d.view = []\n  d.renderedView = null\n  // Holds info about a single rendered line when it was rendered\n  // for measurement, while not in view.\n  d.externalMeasured = null\n  // Empty space (in pixels) above the view\n  d.viewOffset = 0\n  d.lastWrapHeight = d.lastWrapWidth = 0\n  d.updateLineNumbers = null\n\n  d.nativeBarWidth = d.barHeight = d.barWidth = 0\n  d.scrollbarsClipped = false\n\n  // Used to only resize the line number gutter when necessary (when\n  // the amount of lines crosses a boundary that makes its width change)\n  d.lineNumWidth = d.lineNumInnerWidth = d.lineNumChars = null\n  // Set to true when a non-horizontal-scrolling line widget is\n  // added. As an optimization, line widget aligning is skipped when\n  // this is false.\n  d.alignWidgets = false\n\n  d.cachedCharWidth = d.cachedTextHeight = d.cachedPaddingH = null\n\n  // Tracks the maximum line length so that the horizontal scrollbar\n  // can be kept static when scrolling.\n  d.maxLine = null\n  d.maxLineLength = 0\n  d.maxLineChanged = false\n\n  // Used for measuring wheel scrolling granularity\n  d.wheelDX = d.wheelDY = d.wheelStartX = d.wheelStartY = null\n\n  // True when shift is held down.\n  d.shift = false\n\n  // Used to track whether anything happened since the context menu\n  // was opened.\n  d.selForContextMenu = null\n\n  d.activeTouch = null\n\n  input.init(d)\n}\n\n// Find the line object corresponding to the given line number.\nfunction getLine(doc, n) {\n  n -= doc.first\n  if (n < 0 || n >= doc.size) { throw new Error(\"There is no line \" + (n + doc.first) + \" in the document.\") }\n  var chunk = doc\n  while (!chunk.lines) {\n    for (var i = 0;; ++i) {\n      var child = chunk.children[i], sz = child.chunkSize()\n      if (n < sz) { chunk = child; break }\n      n -= sz\n    }\n  }\n  return chunk.lines[n]\n}\n\n// Get the part of a document between two positions, as an array of\n// strings.\nfunction getBetween(doc, start, end) {\n  var out = [], n = start.line\n  doc.iter(start.line, end.line + 1, function (line) {\n    var text = line.text\n    if (n == end.line) { text = text.slice(0, end.ch) }\n    if (n == start.line) { text = text.slice(start.ch) }\n    out.push(text)\n    ++n\n  })\n  return out\n}\n// Get the lines between from and to, as array of strings.\nfunction getLines(doc, from, to) {\n  var out = []\n  doc.iter(from, to, function (line) { out.push(line.text) }) // iter aborts when callback returns truthy value\n  return out\n}\n\n// Update the height of a line, propagating the height change\n// upwards to parent nodes.\nfunction updateLineHeight(line, height) {\n  var diff = height - line.height\n  if (diff) { for (var n = line; n; n = n.parent) { n.height += diff } }\n}\n\n// Given a line object, find its line number by walking up through\n// its parent links.\nfunction lineNo(line) {\n  if (line.parent == null) { return null }\n  var cur = line.parent, no = indexOf(cur.lines, line)\n  for (var chunk = cur.parent; chunk; cur = chunk, chunk = chunk.parent) {\n    for (var i = 0;; ++i) {\n      if (chunk.children[i] == cur) { break }\n      no += chunk.children[i].chunkSize()\n    }\n  }\n  return no + cur.first\n}\n\n// Find the line at the given vertical position, using the height\n// information in the document tree.\nfunction lineAtHeight(chunk, h) {\n  var n = chunk.first\n  outer: do {\n    for (var i$1 = 0; i$1 < chunk.children.length; ++i$1) {\n      var child = chunk.children[i$1], ch = child.height\n      if (h < ch) { chunk = child; continue outer }\n      h -= ch\n      n += child.chunkSize()\n    }\n    return n\n  } while (!chunk.lines)\n  var i = 0\n  for (; i < chunk.lines.length; ++i) {\n    var line = chunk.lines[i], lh = line.height\n    if (h < lh) { break }\n    h -= lh\n  }\n  return n + i\n}\n\nfunction isLine(doc, l) {return l >= doc.first && l < doc.first + doc.size}\n\nfunction lineNumberFor(options, i) {\n  return String(options.lineNumberFormatter(i + options.firstLineNumber))\n}\n\n// A Pos instance represents a position within the text.\nfunction Pos(line, ch, sticky) {\n  if ( sticky === void 0 ) sticky = null;\n\n  if (!(this instanceof Pos)) { return new Pos(line, ch, sticky) }\n  this.line = line\n  this.ch = ch\n  this.sticky = sticky\n}\n\n// Compare two positions, return 0 if they are the same, a negative\n// number when a is less, and a positive number otherwise.\nfunction cmp(a, b) { return a.line - b.line || a.ch - b.ch }\n\nfunction equalCursorPos(a, b) { return a.sticky == b.sticky && cmp(a, b) == 0 }\n\nfunction copyPos(x) {return Pos(x.line, x.ch)}\nfunction maxPos(a, b) { return cmp(a, b) < 0 ? b : a }\nfunction minPos(a, b) { return cmp(a, b) < 0 ? a : b }\n\n// Most of the external API clips given positions to make sure they\n// actually exist within the document.\nfunction clipLine(doc, n) {return Math.max(doc.first, Math.min(n, doc.first + doc.size - 1))}\nfunction clipPos(doc, pos) {\n  if (pos.line < doc.first) { return Pos(doc.first, 0) }\n  var last = doc.first + doc.size - 1\n  if (pos.line > last) { return Pos(last, getLine(doc, last).text.length) }\n  return clipToLen(pos, getLine(doc, pos.line).text.length)\n}\nfunction clipToLen(pos, linelen) {\n  var ch = pos.ch\n  if (ch == null || ch > linelen) { return Pos(pos.line, linelen) }\n  else if (ch < 0) { return Pos(pos.line, 0) }\n  else { return pos }\n}\nfunction clipPosArray(doc, array) {\n  var out = []\n  for (var i = 0; i < array.length; i++) { out[i] = clipPos(doc, array[i]) }\n  return out\n}\n\n// Optimize some code when these features are not used.\nvar sawReadOnlySpans = false;\nvar sawCollapsedSpans = false;\nfunction seeReadOnlySpans() {\n  sawReadOnlySpans = true\n}\n\nfunction seeCollapsedSpans() {\n  sawCollapsedSpans = true\n}\n\n// TEXTMARKER SPANS\n\nfunction MarkedSpan(marker, from, to) {\n  this.marker = marker\n  this.from = from; this.to = to\n}\n\n// Search an array of spans for a span matching the given marker.\nfunction getMarkedSpanFor(spans, marker) {\n  if (spans) { for (var i = 0; i < spans.length; ++i) {\n    var span = spans[i]\n    if (span.marker == marker) { return span }\n  } }\n}\n// Remove a span from an array, returning undefined if no spans are\n// left (we don't store arrays for lines without spans).\nfunction removeMarkedSpan(spans, span) {\n  var r\n  for (var i = 0; i < spans.length; ++i)\n    { if (spans[i] != span) { (r || (r = [])).push(spans[i]) } }\n  return r\n}\n// Add a span to a line.\nfunction addMarkedSpan(line, span) {\n  line.markedSpans = line.markedSpans ? line.markedSpans.concat([span]) : [span]\n  span.marker.attachLine(line)\n}\n\n// Used for the algorithm that adjusts markers for a change in the\n// document. These functions cut an array of spans at a given\n// character position, returning an array of remaining chunks (or\n// undefined if nothing remains).\nfunction markedSpansBefore(old, startCh, isInsert) {\n  var nw\n  if (old) { for (var i = 0; i < old.length; ++i) {\n    var span = old[i], marker = span.marker\n    var startsBefore = span.from == null || (marker.inclusiveLeft ? span.from <= startCh : span.from < startCh)\n    if (startsBefore || span.from == startCh && marker.type == \"bookmark\" && (!isInsert || !span.marker.insertLeft)) {\n      var endsAfter = span.to == null || (marker.inclusiveRight ? span.to >= startCh : span.to > startCh)\n      ;(nw || (nw = [])).push(new MarkedSpan(marker, span.from, endsAfter ? null : span.to))\n    }\n  } }\n  return nw\n}\nfunction markedSpansAfter(old, endCh, isInsert) {\n  var nw\n  if (old) { for (var i = 0; i < old.length; ++i) {\n    var span = old[i], marker = span.marker\n    var endsAfter = span.to == null || (marker.inclusiveRight ? span.to >= endCh : span.to > endCh)\n    if (endsAfter || span.from == endCh && marker.type == \"bookmark\" && (!isInsert || span.marker.insertLeft)) {\n      var startsBefore = span.from == null || (marker.inclusiveLeft ? span.from <= endCh : span.from < endCh)\n      ;(nw || (nw = [])).push(new MarkedSpan(marker, startsBefore ? null : span.from - endCh,\n                                            span.to == null ? null : span.to - endCh))\n    }\n  } }\n  return nw\n}\n\n// Given a change object, compute the new set of marker spans that\n// cover the line in which the change took place. Removes spans\n// entirely within the change, reconnects spans belonging to the\n// same marker that appear on both sides of the change, and cuts off\n// spans partially within the change. Returns an array of span\n// arrays with one element for each line in (after) the change.\nfunction stretchSpansOverChange(doc, change) {\n  if (change.full) { return null }\n  var oldFirst = isLine(doc, change.from.line) && getLine(doc, change.from.line).markedSpans\n  var oldLast = isLine(doc, change.to.line) && getLine(doc, change.to.line).markedSpans\n  if (!oldFirst && !oldLast) { return null }\n\n  var startCh = change.from.ch, endCh = change.to.ch, isInsert = cmp(change.from, change.to) == 0\n  // Get the spans that 'stick out' on both sides\n  var first = markedSpansBefore(oldFirst, startCh, isInsert)\n  var last = markedSpansAfter(oldLast, endCh, isInsert)\n\n  // Next, merge those two ends\n  var sameLine = change.text.length == 1, offset = lst(change.text).length + (sameLine ? startCh : 0)\n  if (first) {\n    // Fix up .to properties of first\n    for (var i = 0; i < first.length; ++i) {\n      var span = first[i]\n      if (span.to == null) {\n        var found = getMarkedSpanFor(last, span.marker)\n        if (!found) { span.to = startCh }\n        else if (sameLine) { span.to = found.to == null ? null : found.to + offset }\n      }\n    }\n  }\n  if (last) {\n    // Fix up .from in last (or move them into first in case of sameLine)\n    for (var i$1 = 0; i$1 < last.length; ++i$1) {\n      var span$1 = last[i$1]\n      if (span$1.to != null) { span$1.to += offset }\n      if (span$1.from == null) {\n        var found$1 = getMarkedSpanFor(first, span$1.marker)\n        if (!found$1) {\n          span$1.from = offset\n          if (sameLine) { (first || (first = [])).push(span$1) }\n        }\n      } else {\n        span$1.from += offset\n        if (sameLine) { (first || (first = [])).push(span$1) }\n      }\n    }\n  }\n  // Make sure we didn't create any zero-length spans\n  if (first) { first = clearEmptySpans(first) }\n  if (last && last != first) { last = clearEmptySpans(last) }\n\n  var newMarkers = [first]\n  if (!sameLine) {\n    // Fill gap with whole-line-spans\n    var gap = change.text.length - 2, gapMarkers\n    if (gap > 0 && first)\n      { for (var i$2 = 0; i$2 < first.length; ++i$2)\n        { if (first[i$2].to == null)\n          { (gapMarkers || (gapMarkers = [])).push(new MarkedSpan(first[i$2].marker, null, null)) } } }\n    for (var i$3 = 0; i$3 < gap; ++i$3)\n      { newMarkers.push(gapMarkers) }\n    newMarkers.push(last)\n  }\n  return newMarkers\n}\n\n// Remove spans that are empty and don't have a clearWhenEmpty\n// option of false.\nfunction clearEmptySpans(spans) {\n  for (var i = 0; i < spans.length; ++i) {\n    var span = spans[i]\n    if (span.from != null && span.from == span.to && span.marker.clearWhenEmpty !== false)\n      { spans.splice(i--, 1) }\n  }\n  if (!spans.length) { return null }\n  return spans\n}\n\n// Used to 'clip' out readOnly ranges when making a change.\nfunction removeReadOnlyRanges(doc, from, to) {\n  var markers = null\n  doc.iter(from.line, to.line + 1, function (line) {\n    if (line.markedSpans) { for (var i = 0; i < line.markedSpans.length; ++i) {\n      var mark = line.markedSpans[i].marker\n      if (mark.readOnly && (!markers || indexOf(markers, mark) == -1))\n        { (markers || (markers = [])).push(mark) }\n    } }\n  })\n  if (!markers) { return null }\n  var parts = [{from: from, to: to}]\n  for (var i = 0; i < markers.length; ++i) {\n    var mk = markers[i], m = mk.find(0)\n    for (var j = 0; j < parts.length; ++j) {\n      var p = parts[j]\n      if (cmp(p.to, m.from) < 0 || cmp(p.from, m.to) > 0) { continue }\n      var newParts = [j, 1], dfrom = cmp(p.from, m.from), dto = cmp(p.to, m.to)\n      if (dfrom < 0 || !mk.inclusiveLeft && !dfrom)\n        { newParts.push({from: p.from, to: m.from}) }\n      if (dto > 0 || !mk.inclusiveRight && !dto)\n        { newParts.push({from: m.to, to: p.to}) }\n      parts.splice.apply(parts, newParts)\n      j += newParts.length - 3\n    }\n  }\n  return parts\n}\n\n// Connect or disconnect spans from a line.\nfunction detachMarkedSpans(line) {\n  var spans = line.markedSpans\n  if (!spans) { return }\n  for (var i = 0; i < spans.length; ++i)\n    { spans[i].marker.detachLine(line) }\n  line.markedSpans = null\n}\nfunction attachMarkedSpans(line, spans) {\n  if (!spans) { return }\n  for (var i = 0; i < spans.length; ++i)\n    { spans[i].marker.attachLine(line) }\n  line.markedSpans = spans\n}\n\n// Helpers used when computing which overlapping collapsed span\n// counts as the larger one.\nfunction extraLeft(marker) { return marker.inclusiveLeft ? -1 : 0 }\nfunction extraRight(marker) { return marker.inclusiveRight ? 1 : 0 }\n\n// Returns a number indicating which of two overlapping collapsed\n// spans is larger (and thus includes the other). Falls back to\n// comparing ids when the spans cover exactly the same range.\nfunction compareCollapsedMarkers(a, b) {\n  var lenDiff = a.lines.length - b.lines.length\n  if (lenDiff != 0) { return lenDiff }\n  var aPos = a.find(), bPos = b.find()\n  var fromCmp = cmp(aPos.from, bPos.from) || extraLeft(a) - extraLeft(b)\n  if (fromCmp) { return -fromCmp }\n  var toCmp = cmp(aPos.to, bPos.to) || extraRight(a) - extraRight(b)\n  if (toCmp) { return toCmp }\n  return b.id - a.id\n}\n\n// Find out whether a line ends or starts in a collapsed span. If\n// so, return the marker for that span.\nfunction collapsedSpanAtSide(line, start) {\n  var sps = sawCollapsedSpans && line.markedSpans, found\n  if (sps) { for (var sp = (void 0), i = 0; i < sps.length; ++i) {\n    sp = sps[i]\n    if (sp.marker.collapsed && (start ? sp.from : sp.to) == null &&\n        (!found || compareCollapsedMarkers(found, sp.marker) < 0))\n      { found = sp.marker }\n  } }\n  return found\n}\nfunction collapsedSpanAtStart(line) { return collapsedSpanAtSide(line, true) }\nfunction collapsedSpanAtEnd(line) { return collapsedSpanAtSide(line, false) }\n\n// Test whether there exists a collapsed span that partially\n// overlaps (covers the start or end, but not both) of a new span.\n// Such overlap is not allowed.\nfunction conflictingCollapsedRange(doc, lineNo, from, to, marker) {\n  var line = getLine(doc, lineNo)\n  var sps = sawCollapsedSpans && line.markedSpans\n  if (sps) { for (var i = 0; i < sps.length; ++i) {\n    var sp = sps[i]\n    if (!sp.marker.collapsed) { continue }\n    var found = sp.marker.find(0)\n    var fromCmp = cmp(found.from, from) || extraLeft(sp.marker) - extraLeft(marker)\n    var toCmp = cmp(found.to, to) || extraRight(sp.marker) - extraRight(marker)\n    if (fromCmp >= 0 && toCmp <= 0 || fromCmp <= 0 && toCmp >= 0) { continue }\n    if (fromCmp <= 0 && (sp.marker.inclusiveRight && marker.inclusiveLeft ? cmp(found.to, from) >= 0 : cmp(found.to, from) > 0) ||\n        fromCmp >= 0 && (sp.marker.inclusiveRight && marker.inclusiveLeft ? cmp(found.from, to) <= 0 : cmp(found.from, to) < 0))\n      { return true }\n  } }\n}\n\n// A visual line is a line as drawn on the screen. Folding, for\n// example, can cause multiple logical lines to appear on the same\n// visual line. This finds the start of the visual line that the\n// given line is part of (usually that is the line itself).\nfunction visualLine(line) {\n  var merged\n  while (merged = collapsedSpanAtStart(line))\n    { line = merged.find(-1, true).line }\n  return line\n}\n\nfunction visualLineEnd(line) {\n  var merged\n  while (merged = collapsedSpanAtEnd(line))\n    { line = merged.find(1, true).line }\n  return line\n}\n\n// Returns an array of logical lines that continue the visual line\n// started by the argument, or undefined if there are no such lines.\nfunction visualLineContinued(line) {\n  var merged, lines\n  while (merged = collapsedSpanAtEnd(line)) {\n    line = merged.find(1, true).line\n    ;(lines || (lines = [])).push(line)\n  }\n  return lines\n}\n\n// Get the line number of the start of the visual line that the\n// given line number is part of.\nfunction visualLineNo(doc, lineN) {\n  var line = getLine(doc, lineN), vis = visualLine(line)\n  if (line == vis) { return lineN }\n  return lineNo(vis)\n}\n\n// Get the line number of the start of the next visual line after\n// the given line.\nfunction visualLineEndNo(doc, lineN) {\n  if (lineN > doc.lastLine()) { return lineN }\n  var line = getLine(doc, lineN), merged\n  if (!lineIsHidden(doc, line)) { return lineN }\n  while (merged = collapsedSpanAtEnd(line))\n    { line = merged.find(1, true).line }\n  return lineNo(line) + 1\n}\n\n// Compute whether a line is hidden. Lines count as hidden when they\n// are part of a visual line that starts with another line, or when\n// they are entirely covered by collapsed, non-widget span.\nfunction lineIsHidden(doc, line) {\n  var sps = sawCollapsedSpans && line.markedSpans\n  if (sps) { for (var sp = (void 0), i = 0; i < sps.length; ++i) {\n    sp = sps[i]\n    if (!sp.marker.collapsed) { continue }\n    if (sp.from == null) { return true }\n    if (sp.marker.widgetNode) { continue }\n    if (sp.from == 0 && sp.marker.inclusiveLeft && lineIsHiddenInner(doc, line, sp))\n      { return true }\n  } }\n}\nfunction lineIsHiddenInner(doc, line, span) {\n  if (span.to == null) {\n    var end = span.marker.find(1, true)\n    return lineIsHiddenInner(doc, end.line, getMarkedSpanFor(end.line.markedSpans, span.marker))\n  }\n  if (span.marker.inclusiveRight && span.to == line.text.length)\n    { return true }\n  for (var sp = (void 0), i = 0; i < line.markedSpans.length; ++i) {\n    sp = line.markedSpans[i]\n    if (sp.marker.collapsed && !sp.marker.widgetNode && sp.from == span.to &&\n        (sp.to == null || sp.to != span.from) &&\n        (sp.marker.inclusiveLeft || span.marker.inclusiveRight) &&\n        lineIsHiddenInner(doc, line, sp)) { return true }\n  }\n}\n\n// Find the height above the given line.\nfunction heightAtLine(lineObj) {\n  lineObj = visualLine(lineObj)\n\n  var h = 0, chunk = lineObj.parent\n  for (var i = 0; i < chunk.lines.length; ++i) {\n    var line = chunk.lines[i]\n    if (line == lineObj) { break }\n    else { h += line.height }\n  }\n  for (var p = chunk.parent; p; chunk = p, p = chunk.parent) {\n    for (var i$1 = 0; i$1 < p.children.length; ++i$1) {\n      var cur = p.children[i$1]\n      if (cur == chunk) { break }\n      else { h += cur.height }\n    }\n  }\n  return h\n}\n\n// Compute the character length of a line, taking into account\n// collapsed ranges (see markText) that might hide parts, and join\n// other lines onto it.\nfunction lineLength(line) {\n  if (line.height == 0) { return 0 }\n  var len = line.text.length, merged, cur = line\n  while (merged = collapsedSpanAtStart(cur)) {\n    var found = merged.find(0, true)\n    cur = found.from.line\n    len += found.from.ch - found.to.ch\n  }\n  cur = line\n  while (merged = collapsedSpanAtEnd(cur)) {\n    var found$1 = merged.find(0, true)\n    len -= cur.text.length - found$1.from.ch\n    cur = found$1.to.line\n    len += cur.text.length - found$1.to.ch\n  }\n  return len\n}\n\n// Find the longest line in the document.\nfunction findMaxLine(cm) {\n  var d = cm.display, doc = cm.doc\n  d.maxLine = getLine(doc, doc.first)\n  d.maxLineLength = lineLength(d.maxLine)\n  d.maxLineChanged = true\n  doc.iter(function (line) {\n    var len = lineLength(line)\n    if (len > d.maxLineLength) {\n      d.maxLineLength = len\n      d.maxLine = line\n    }\n  })\n}\n\n// BIDI HELPERS\n\nfunction iterateBidiSections(order, from, to, f) {\n  if (!order) { return f(from, to, \"ltr\") }\n  var found = false\n  for (var i = 0; i < order.length; ++i) {\n    var part = order[i]\n    if (part.from < to && part.to > from || from == to && part.to == from) {\n      f(Math.max(part.from, from), Math.min(part.to, to), part.level == 1 ? \"rtl\" : \"ltr\")\n      found = true\n    }\n  }\n  if (!found) { f(from, to, \"ltr\") }\n}\n\nvar bidiOther = null\nfunction getBidiPartAt(order, ch, sticky) {\n  var found\n  bidiOther = null\n  for (var i = 0; i < order.length; ++i) {\n    var cur = order[i]\n    if (cur.from < ch && cur.to > ch) { return i }\n    if (cur.to == ch) {\n      if (cur.from != cur.to && sticky == \"before\") { found = i }\n      else { bidiOther = i }\n    }\n    if (cur.from == ch) {\n      if (cur.from != cur.to && sticky != \"before\") { found = i }\n      else { bidiOther = i }\n    }\n  }\n  return found != null ? found : bidiOther\n}\n\n// Bidirectional ordering algorithm\n// See http://unicode.org/reports/tr9/tr9-13.html for the algorithm\n// that this (partially) implements.\n\n// One-char codes used for character types:\n// L (L):   Left-to-Right\n// R (R):   Right-to-Left\n// r (AL):  Right-to-Left Arabic\n// 1 (EN):  European Number\n// + (ES):  European Number Separator\n// % (ET):  European Number Terminator\n// n (AN):  Arabic Number\n// , (CS):  Common Number Separator\n// m (NSM): Non-Spacing Mark\n// b (BN):  Boundary Neutral\n// s (B):   Paragraph Separator\n// t (S):   Segment Separator\n// w (WS):  Whitespace\n// N (ON):  Other Neutrals\n\n// Returns null if characters are ordered as they appear\n// (left-to-right), or an array of sections ({from, to, level}\n// objects) in the order in which they occur visually.\nvar bidiOrdering = (function() {\n  // Character types for codepoints 0 to 0xff\n  var lowTypes = \"bbbbbbbbbtstwsbbbbbbbbbbbbbbssstwNN%%%NNNNNN,N,N1111111111NNNNNNNLLLLLLLLLLLLLLLLLLLLLLLLLLNNNNNNLLLLLLLLLLLLLLLLLLLLLLLLLLNNNNbbbbbbsbbbbbbbbbbbbbbbbbbbbbbbbbb,N%%%%NNNNLNNNNN%%11NLNNN1LNNNNNLLLLLLLLLLLLLLLLLLLLLLLNLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLN\"\n  // Character types for codepoints 0x600 to 0x6f9\n  var arabicTypes = \"nnnnnnNNr%%r,rNNmmmmmmmmmmmrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrmmmmmmmmmmmmmmmmmmmmmnnnnnnnnnn%nnrrrmrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrmmmmmmmnNmmmmmmrrmmNmmmmrr1111111111\"\n  function charType(code) {\n    if (code <= 0xf7) { return lowTypes.charAt(code) }\n    else if (0x590 <= code && code <= 0x5f4) { return \"R\" }\n    else if (0x600 <= code && code <= 0x6f9) { return arabicTypes.charAt(code - 0x600) }\n    else if (0x6ee <= code && code <= 0x8ac) { return \"r\" }\n    else if (0x2000 <= code && code <= 0x200b) { return \"w\" }\n    else if (code == 0x200c) { return \"b\" }\n    else { return \"L\" }\n  }\n\n  var bidiRE = /[\\u0590-\\u05f4\\u0600-\\u06ff\\u0700-\\u08ac]/\n  var isNeutral = /[stwN]/, isStrong = /[LRr]/, countsAsLeft = /[Lb1n]/, countsAsNum = /[1n]/\n  // Browsers seem to always treat the boundaries of block elements as being L.\n  var outerType = \"L\"\n\n  function BidiSpan(level, from, to) {\n    this.level = level\n    this.from = from; this.to = to\n  }\n\n  return function(str) {\n    if (!bidiRE.test(str)) { return false }\n    var len = str.length, types = []\n    for (var i = 0; i < len; ++i)\n      { types.push(charType(str.charCodeAt(i))) }\n\n    // W1. Examine each non-spacing mark (NSM) in the level run, and\n    // change the type of the NSM to the type of the previous\n    // character. If the NSM is at the start of the level run, it will\n    // get the type of sor.\n    for (var i$1 = 0, prev = outerType; i$1 < len; ++i$1) {\n      var type = types[i$1]\n      if (type == \"m\") { types[i$1] = prev }\n      else { prev = type }\n    }\n\n    // W2. Search backwards from each instance of a European number\n    // until the first strong type (R, L, AL, or sor) is found. If an\n    // AL is found, change the type of the European number to Arabic\n    // number.\n    // W3. Change all ALs to R.\n    for (var i$2 = 0, cur = outerType; i$2 < len; ++i$2) {\n      var type$1 = types[i$2]\n      if (type$1 == \"1\" && cur == \"r\") { types[i$2] = \"n\" }\n      else if (isStrong.test(type$1)) { cur = type$1; if (type$1 == \"r\") { types[i$2] = \"R\" } }\n    }\n\n    // W4. A single European separator between two European numbers\n    // changes to a European number. A single common separator between\n    // two numbers of the same type changes to that type.\n    for (var i$3 = 1, prev$1 = types[0]; i$3 < len - 1; ++i$3) {\n      var type$2 = types[i$3]\n      if (type$2 == \"+\" && prev$1 == \"1\" && types[i$3+1] == \"1\") { types[i$3] = \"1\" }\n      else if (type$2 == \",\" && prev$1 == types[i$3+1] &&\n               (prev$1 == \"1\" || prev$1 == \"n\")) { types[i$3] = prev$1 }\n      prev$1 = type$2\n    }\n\n    // W5. A sequence of European terminators adjacent to European\n    // numbers changes to all European numbers.\n    // W6. Otherwise, separators and terminators change to Other\n    // Neutral.\n    for (var i$4 = 0; i$4 < len; ++i$4) {\n      var type$3 = types[i$4]\n      if (type$3 == \",\") { types[i$4] = \"N\" }\n      else if (type$3 == \"%\") {\n        var end = (void 0)\n        for (end = i$4 + 1; end < len && types[end] == \"%\"; ++end) {}\n        var replace = (i$4 && types[i$4-1] == \"!\") || (end < len && types[end] == \"1\") ? \"1\" : \"N\"\n        for (var j = i$4; j < end; ++j) { types[j] = replace }\n        i$4 = end - 1\n      }\n    }\n\n    // W7. Search backwards from each instance of a European number\n    // until the first strong type (R, L, or sor) is found. If an L is\n    // found, then change the type of the European number to L.\n    for (var i$5 = 0, cur$1 = outerType; i$5 < len; ++i$5) {\n      var type$4 = types[i$5]\n      if (cur$1 == \"L\" && type$4 == \"1\") { types[i$5] = \"L\" }\n      else if (isStrong.test(type$4)) { cur$1 = type$4 }\n    }\n\n    // N1. A sequence of neutrals takes the direction of the\n    // surrounding strong text if the text on both sides has the same\n    // direction. European and Arabic numbers act as if they were R in\n    // terms of their influence on neutrals. Start-of-level-run (sor)\n    // and end-of-level-run (eor) are used at level run boundaries.\n    // N2. Any remaining neutrals take the embedding direction.\n    for (var i$6 = 0; i$6 < len; ++i$6) {\n      if (isNeutral.test(types[i$6])) {\n        var end$1 = (void 0)\n        for (end$1 = i$6 + 1; end$1 < len && isNeutral.test(types[end$1]); ++end$1) {}\n        var before = (i$6 ? types[i$6-1] : outerType) == \"L\"\n        var after = (end$1 < len ? types[end$1] : outerType) == \"L\"\n        var replace$1 = before || after ? \"L\" : \"R\"\n        for (var j$1 = i$6; j$1 < end$1; ++j$1) { types[j$1] = replace$1 }\n        i$6 = end$1 - 1\n      }\n    }\n\n    // Here we depart from the documented algorithm, in order to avoid\n    // building up an actual levels array. Since there are only three\n    // levels (0, 1, 2) in an implementation that doesn't take\n    // explicit embedding into account, we can build up the order on\n    // the fly, without following the level-based algorithm.\n    var order = [], m\n    for (var i$7 = 0; i$7 < len;) {\n      if (countsAsLeft.test(types[i$7])) {\n        var start = i$7\n        for (++i$7; i$7 < len && countsAsLeft.test(types[i$7]); ++i$7) {}\n        order.push(new BidiSpan(0, start, i$7))\n      } else {\n        var pos = i$7, at = order.length\n        for (++i$7; i$7 < len && types[i$7] != \"L\"; ++i$7) {}\n        for (var j$2 = pos; j$2 < i$7;) {\n          if (countsAsNum.test(types[j$2])) {\n            if (pos < j$2) { order.splice(at, 0, new BidiSpan(1, pos, j$2)) }\n            var nstart = j$2\n            for (++j$2; j$2 < i$7 && countsAsNum.test(types[j$2]); ++j$2) {}\n            order.splice(at, 0, new BidiSpan(2, nstart, j$2))\n            pos = j$2\n          } else { ++j$2 }\n        }\n        if (pos < i$7) { order.splice(at, 0, new BidiSpan(1, pos, i$7)) }\n      }\n    }\n    if (order[0].level == 1 && (m = str.match(/^\\s+/))) {\n      order[0].from = m[0].length\n      order.unshift(new BidiSpan(0, 0, m[0].length))\n    }\n    if (lst(order).level == 1 && (m = str.match(/\\s+$/))) {\n      lst(order).to -= m[0].length\n      order.push(new BidiSpan(0, len - m[0].length, len))\n    }\n\n    return order\n  }\n})()\n\n// Get the bidi ordering for the given line (and cache it). Returns\n// false for lines that are fully left-to-right, and an array of\n// BidiSpan objects otherwise.\nfunction getOrder(line) {\n  var order = line.order\n  if (order == null) { order = line.order = bidiOrdering(line.text) }\n  return order\n}\n\nfunction moveCharLogically(line, ch, dir) {\n  var target = skipExtendingChars(line.text, ch + dir, dir)\n  return target < 0 || target > line.text.length ? null : target\n}\n\nfunction moveLogically(line, start, dir) {\n  var ch = moveCharLogically(line, start.ch, dir)\n  return ch == null ? null : new Pos(start.line, ch, dir < 0 ? \"after\" : \"before\")\n}\n\nfunction endOfLine(visually, cm, lineObj, lineNo, dir) {\n  if (visually) {\n    var order = getOrder(lineObj)\n    if (order) {\n      var part = dir < 0 ? lst(order) : order[0]\n      var moveInStorageOrder = (dir < 0) == (part.level == 1)\n      var sticky = moveInStorageOrder ? \"after\" : \"before\"\n      var ch\n      // With a wrapped rtl chunk (possibly spanning multiple bidi parts),\n      // it could be that the last bidi part is not on the last visual line,\n      // since visual lines contain content order-consecutive chunks.\n      // Thus, in rtl, we are looking for the first (content-order) character\n      // in the rtl chunk that is on the last line (that is, the same line\n      // as the last (content-order) character).\n      if (part.level > 0) {\n        var prep = prepareMeasureForLine(cm, lineObj)\n        ch = dir < 0 ? lineObj.text.length - 1 : 0\n        var targetTop = measureCharPrepared(cm, prep, ch).top\n        ch = findFirst(function (ch) { return measureCharPrepared(cm, prep, ch).top == targetTop; }, (dir < 0) == (part.level == 1) ? part.from : part.to - 1, ch)\n        if (sticky == \"before\") { ch = moveCharLogically(lineObj, ch, 1, true) }\n      } else { ch = dir < 0 ? part.to : part.from }\n      return new Pos(lineNo, ch, sticky)\n    }\n  }\n  return new Pos(lineNo, dir < 0 ? lineObj.text.length : 0, dir < 0 ? \"before\" : \"after\")\n}\n\nfunction moveVisually(cm, line, start, dir) {\n  var bidi = getOrder(line)\n  if (!bidi) { return moveLogically(line, start, dir) }\n  if (start.ch >= line.text.length) {\n    start.ch = line.text.length\n    start.sticky = \"before\"\n  } else if (start.ch <= 0) {\n    start.ch = 0\n    start.sticky = \"after\"\n  }\n  var partPos = getBidiPartAt(bidi, start.ch, start.sticky), part = bidi[partPos]\n  if (part.level % 2 == 0 && (dir > 0 ? part.to > start.ch : part.from < start.ch)) {\n    // Case 1: We move within an ltr part. Even with wrapped lines,\n    // nothing interesting happens.\n    return moveLogically(line, start, dir)\n  }\n\n  var mv = function (pos, dir) { return moveCharLogically(line, pos instanceof Pos ? pos.ch : pos, dir); }\n  var prep\n  var getWrappedLineExtent = function (ch) {\n    if (!cm.options.lineWrapping) { return {begin: 0, end: line.text.length} }\n    prep = prep || prepareMeasureForLine(cm, line)\n    return wrappedLineExtentChar(cm, line, prep, ch)\n  }\n  var wrappedLineExtent = getWrappedLineExtent(start.sticky == \"before\" ? mv(start, -1) : start.ch)\n\n  if (part.level % 2 == 1) {\n    var ch = mv(start, -dir)\n    if (ch != null && (dir > 0 ? ch >= part.from && ch >= wrappedLineExtent.begin : ch <= part.to && ch <= wrappedLineExtent.end)) {\n      // Case 2: We move within an rtl part on the same visual line\n      var sticky = dir < 0 ? \"before\" : \"after\"\n      return new Pos(start.line, ch, sticky)\n    }\n  }\n\n  // Case 3: Could not move within this bidi part in this visual line, so leave\n  // the current bidi part\n\n  var searchInVisualLine = function (partPos, dir, wrappedLineExtent) {\n    var getRes = function (ch, moveInStorageOrder) { return moveInStorageOrder\n      ? new Pos(start.line, mv(ch, 1), \"before\")\n      : new Pos(start.line, ch, \"after\"); }\n\n    for (; partPos >= 0 && partPos < bidi.length; partPos += dir) {\n      var part = bidi[partPos]\n      var moveInStorageOrder = (dir > 0) == (part.level != 1)\n      var ch = moveInStorageOrder ? wrappedLineExtent.begin : mv(wrappedLineExtent.end, -1)\n      if (part.from <= ch && ch < part.to) { return getRes(ch, moveInStorageOrder) }\n      ch = moveInStorageOrder ? part.from : mv(part.to, -1)\n      if (wrappedLineExtent.begin <= ch && ch < wrappedLineExtent.end) { return getRes(ch, moveInStorageOrder) }\n    }\n  }\n\n  // Case 3a: Look for other bidi parts on the same visual line\n  var res = searchInVisualLine(partPos + dir, dir, wrappedLineExtent)\n  if (res) { return res }\n\n  // Case 3b: Look for other bidi parts on the next visual line\n  var nextCh = dir > 0 ? wrappedLineExtent.end : mv(wrappedLineExtent.begin, -1)\n  if (nextCh != null && !(dir > 0 && nextCh == line.text.length)) {\n    res = searchInVisualLine(dir > 0 ? 0 : bidi.length - 1, dir, getWrappedLineExtent(nextCh))\n    if (res) { return res }\n  }\n\n  // Case 4: Nowhere to move\n  return null\n}\n\n// EVENT HANDLING\n\n// Lightweight event framework. on/off also work on DOM nodes,\n// registering native DOM handlers.\n\nvar noHandlers = []\n\nvar on = function(emitter, type, f) {\n  if (emitter.addEventListener) {\n    emitter.addEventListener(type, f, false)\n  } else if (emitter.attachEvent) {\n    emitter.attachEvent(\"on\" + type, f)\n  } else {\n    var map = emitter._handlers || (emitter._handlers = {})\n    map[type] = (map[type] || noHandlers).concat(f)\n  }\n}\n\nfunction getHandlers(emitter, type) {\n  return emitter._handlers && emitter._handlers[type] || noHandlers\n}\n\nfunction off(emitter, type, f) {\n  if (emitter.removeEventListener) {\n    emitter.removeEventListener(type, f, false)\n  } else if (emitter.detachEvent) {\n    emitter.detachEvent(\"on\" + type, f)\n  } else {\n    var map = emitter._handlers, arr = map && map[type]\n    if (arr) {\n      var index = indexOf(arr, f)\n      if (index > -1)\n        { map[type] = arr.slice(0, index).concat(arr.slice(index + 1)) }\n    }\n  }\n}\n\nfunction signal(emitter, type /*, values...*/) {\n  var handlers = getHandlers(emitter, type)\n  if (!handlers.length) { return }\n  var args = Array.prototype.slice.call(arguments, 2)\n  for (var i = 0; i < handlers.length; ++i) { handlers[i].apply(null, args) }\n}\n\n// The DOM events that CodeMirror handles can be overridden by\n// registering a (non-DOM) handler on the editor for the event name,\n// and preventDefault-ing the event in that handler.\nfunction signalDOMEvent(cm, e, override) {\n  if (typeof e == \"string\")\n    { e = {type: e, preventDefault: function() { this.defaultPrevented = true }} }\n  signal(cm, override || e.type, cm, e)\n  return e_defaultPrevented(e) || e.codemirrorIgnore\n}\n\nfunction signalCursorActivity(cm) {\n  var arr = cm._handlers && cm._handlers.cursorActivity\n  if (!arr) { return }\n  var set = cm.curOp.cursorActivityHandlers || (cm.curOp.cursorActivityHandlers = [])\n  for (var i = 0; i < arr.length; ++i) { if (indexOf(set, arr[i]) == -1)\n    { set.push(arr[i]) } }\n}\n\nfunction hasHandler(emitter, type) {\n  return getHandlers(emitter, type).length > 0\n}\n\n// Add on and off methods to a constructor's prototype, to make\n// registering events on such objects more convenient.\nfunction eventMixin(ctor) {\n  ctor.prototype.on = function(type, f) {on(this, type, f)}\n  ctor.prototype.off = function(type, f) {off(this, type, f)}\n}\n\n// Due to the fact that we still support jurassic IE versions, some\n// compatibility wrappers are needed.\n\nfunction e_preventDefault(e) {\n  if (e.preventDefault) { e.preventDefault() }\n  else { e.returnValue = false }\n}\nfunction e_stopPropagation(e) {\n  if (e.stopPropagation) { e.stopPropagation() }\n  else { e.cancelBubble = true }\n}\nfunction e_defaultPrevented(e) {\n  return e.defaultPrevented != null ? e.defaultPrevented : e.returnValue == false\n}\nfunction e_stop(e) {e_preventDefault(e); e_stopPropagation(e)}\n\nfunction e_target(e) {return e.target || e.srcElement}\nfunction e_button(e) {\n  var b = e.which\n  if (b == null) {\n    if (e.button & 1) { b = 1 }\n    else if (e.button & 2) { b = 3 }\n    else if (e.button & 4) { b = 2 }\n  }\n  if (mac && e.ctrlKey && b == 1) { b = 3 }\n  return b\n}\n\n// Detect drag-and-drop\nvar dragAndDrop = function() {\n  // There is *some* kind of drag-and-drop support in IE6-8, but I\n  // couldn't get it to work yet.\n  if (ie && ie_version < 9) { return false }\n  var div = elt('div')\n  return \"draggable\" in div || \"dragDrop\" in div\n}()\n\nvar zwspSupported\nfunction zeroWidthElement(measure) {\n  if (zwspSupported == null) {\n    var test = elt(\"span\", \"\\u200b\")\n    removeChildrenAndAdd(measure, elt(\"span\", [test, document.createTextNode(\"x\")]))\n    if (measure.firstChild.offsetHeight != 0)\n      { zwspSupported = test.offsetWidth <= 1 && test.offsetHeight > 2 && !(ie && ie_version < 8) }\n  }\n  var node = zwspSupported ? elt(\"span\", \"\\u200b\") :\n    elt(\"span\", \"\\u00a0\", null, \"display: inline-block; width: 1px; margin-right: -1px\")\n  node.setAttribute(\"cm-text\", \"\")\n  return node\n}\n\n// Feature-detect IE's crummy client rect reporting for bidi text\nvar badBidiRects\nfunction hasBadBidiRects(measure) {\n  if (badBidiRects != null) { return badBidiRects }\n  var txt = removeChildrenAndAdd(measure, document.createTextNode(\"A\\u062eA\"))\n  var r0 = range(txt, 0, 1).getBoundingClientRect()\n  var r1 = range(txt, 1, 2).getBoundingClientRect()\n  removeChildren(measure)\n  if (!r0 || r0.left == r0.right) { return false } // Safari returns null in some cases (#2780)\n  return badBidiRects = (r1.right - r0.right < 3)\n}\n\n// See if \"\".split is the broken IE version, if so, provide an\n// alternative way to split lines.\nvar splitLinesAuto = \"\\n\\nb\".split(/\\n/).length != 3 ? function (string) {\n  var pos = 0, result = [], l = string.length\n  while (pos <= l) {\n    var nl = string.indexOf(\"\\n\", pos)\n    if (nl == -1) { nl = string.length }\n    var line = string.slice(pos, string.charAt(nl - 1) == \"\\r\" ? nl - 1 : nl)\n    var rt = line.indexOf(\"\\r\")\n    if (rt != -1) {\n      result.push(line.slice(0, rt))\n      pos += rt + 1\n    } else {\n      result.push(line)\n      pos = nl + 1\n    }\n  }\n  return result\n} : function (string) { return string.split(/\\r\\n?|\\n/); }\n\nvar hasSelection = window.getSelection ? function (te) {\n  try { return te.selectionStart != te.selectionEnd }\n  catch(e) { return false }\n} : function (te) {\n  var range\n  try {range = te.ownerDocument.selection.createRange()}\n  catch(e) {}\n  if (!range || range.parentElement() != te) { return false }\n  return range.compareEndPoints(\"StartToEnd\", range) != 0\n}\n\nvar hasCopyEvent = (function () {\n  var e = elt(\"div\")\n  if (\"oncopy\" in e) { return true }\n  e.setAttribute(\"oncopy\", \"return;\")\n  return typeof e.oncopy == \"function\"\n})()\n\nvar badZoomedRects = null\nfunction hasBadZoomedRects(measure) {\n  if (badZoomedRects != null) { return badZoomedRects }\n  var node = removeChildrenAndAdd(measure, elt(\"span\", \"x\"))\n  var normal = node.getBoundingClientRect()\n  var fromRange = range(node, 0, 1).getBoundingClientRect()\n  return badZoomedRects = Math.abs(normal.left - fromRange.left) > 1\n}\n\nvar modes = {};\nvar mimeModes = {};\n// Extra arguments are stored as the mode's dependencies, which is\n// used by (legacy) mechanisms like loadmode.js to automatically\n// load a mode. (Preferred mechanism is the require/define calls.)\nfunction defineMode(name, mode) {\n  if (arguments.length > 2)\n    { mode.dependencies = Array.prototype.slice.call(arguments, 2) }\n  modes[name] = mode\n}\n\nfunction defineMIME(mime, spec) {\n  mimeModes[mime] = spec\n}\n\n// Given a MIME type, a {name, ...options} config object, or a name\n// string, return a mode config object.\nfunction resolveMode(spec) {\n  if (typeof spec == \"string\" && mimeModes.hasOwnProperty(spec)) {\n    spec = mimeModes[spec]\n  } else if (spec && typeof spec.name == \"string\" && mimeModes.hasOwnProperty(spec.name)) {\n    var found = mimeModes[spec.name]\n    if (typeof found == \"string\") { found = {name: found} }\n    spec = createObj(found, spec)\n    spec.name = found.name\n  } else if (typeof spec == \"string\" && /^[\\w\\-]+\\/[\\w\\-]+\\+xml$/.test(spec)) {\n    return resolveMode(\"application/xml\")\n  } else if (typeof spec == \"string\" && /^[\\w\\-]+\\/[\\w\\-]+\\+json$/.test(spec)) {\n    return resolveMode(\"application/json\")\n  }\n  if (typeof spec == \"string\") { return {name: spec} }\n  else { return spec || {name: \"null\"} }\n}\n\n// Given a mode spec (anything that resolveMode accepts), find and\n// initialize an actual mode object.\nfunction getMode(options, spec) {\n  spec = resolveMode(spec)\n  var mfactory = modes[spec.name]\n  if (!mfactory) { return getMode(options, \"text/plain\") }\n  var modeObj = mfactory(options, spec)\n  if (modeExtensions.hasOwnProperty(spec.name)) {\n    var exts = modeExtensions[spec.name]\n    for (var prop in exts) {\n      if (!exts.hasOwnProperty(prop)) { continue }\n      if (modeObj.hasOwnProperty(prop)) { modeObj[\"_\" + prop] = modeObj[prop] }\n      modeObj[prop] = exts[prop]\n    }\n  }\n  modeObj.name = spec.name\n  if (spec.helperType) { modeObj.helperType = spec.helperType }\n  if (spec.modeProps) { for (var prop$1 in spec.modeProps)\n    { modeObj[prop$1] = spec.modeProps[prop$1] } }\n\n  return modeObj\n}\n\n// This can be used to attach properties to mode objects from\n// outside the actual mode definition.\nvar modeExtensions = {}\nfunction extendMode(mode, properties) {\n  var exts = modeExtensions.hasOwnProperty(mode) ? modeExtensions[mode] : (modeExtensions[mode] = {})\n  copyObj(properties, exts)\n}\n\nfunction copyState(mode, state) {\n  if (state === true) { return state }\n  if (mode.copyState) { return mode.copyState(state) }\n  var nstate = {}\n  for (var n in state) {\n    var val = state[n]\n    if (val instanceof Array) { val = val.concat([]) }\n    nstate[n] = val\n  }\n  return nstate\n}\n\n// Given a mode and a state (for that mode), find the inner mode and\n// state at the position that the state refers to.\nfunction innerMode(mode, state) {\n  var info\n  while (mode.innerMode) {\n    info = mode.innerMode(state)\n    if (!info || info.mode == mode) { break }\n    state = info.state\n    mode = info.mode\n  }\n  return info || {mode: mode, state: state}\n}\n\nfunction startState(mode, a1, a2) {\n  return mode.startState ? mode.startState(a1, a2) : true\n}\n\n// STRING STREAM\n\n// Fed to the mode parsers, provides helper functions to make\n// parsers more succinct.\n\nvar StringStream = function(string, tabSize) {\n  this.pos = this.start = 0\n  this.string = string\n  this.tabSize = tabSize || 8\n  this.lastColumnPos = this.lastColumnValue = 0\n  this.lineStart = 0\n};\n\nStringStream.prototype.eol = function () {return this.pos >= this.string.length};\nStringStream.prototype.sol = function () {return this.pos == this.lineStart};\nStringStream.prototype.peek = function () {return this.string.charAt(this.pos) || undefined};\nStringStream.prototype.next = function () {\n  if (this.pos < this.string.length)\n    { return this.string.charAt(this.pos++) }\n};\nStringStream.prototype.eat = function (match) {\n  var ch = this.string.charAt(this.pos)\n  var ok\n  if (typeof match == \"string\") { ok = ch == match }\n  else { ok = ch && (match.test ? match.test(ch) : match(ch)) }\n  if (ok) {++this.pos; return ch}\n};\nStringStream.prototype.eatWhile = function (match) {\n  var start = this.pos\n  while (this.eat(match)){}\n  return this.pos > start\n};\nStringStream.prototype.eatSpace = function () {\n    var this$1 = this;\n\n  var start = this.pos\n  while (/[\\s\\u00a0]/.test(this.string.charAt(this.pos))) { ++this$1.pos }\n  return this.pos > start\n};\nStringStream.prototype.skipToEnd = function () {this.pos = this.string.length};\nStringStream.prototype.skipTo = function (ch) {\n  var found = this.string.indexOf(ch, this.pos)\n  if (found > -1) {this.pos = found; return true}\n};\nStringStream.prototype.backUp = function (n) {this.pos -= n};\nStringStream.prototype.column = function () {\n  if (this.lastColumnPos < this.start) {\n    this.lastColumnValue = countColumn(this.string, this.start, this.tabSize, this.lastColumnPos, this.lastColumnValue)\n    this.lastColumnPos = this.start\n  }\n  return this.lastColumnValue - (this.lineStart ? countColumn(this.string, this.lineStart, this.tabSize) : 0)\n};\nStringStream.prototype.indentation = function () {\n  return countColumn(this.string, null, this.tabSize) -\n    (this.lineStart ? countColumn(this.string, this.lineStart, this.tabSize) : 0)\n};\nStringStream.prototype.match = function (pattern, consume, caseInsensitive) {\n  if (typeof pattern == \"string\") {\n    var cased = function (str) { return caseInsensitive ? str.toLowerCase() : str; }\n    var substr = this.string.substr(this.pos, pattern.length)\n    if (cased(substr) == cased(pattern)) {\n      if (consume !== false) { this.pos += pattern.length }\n      return true\n    }\n  } else {\n    var match = this.string.slice(this.pos).match(pattern)\n    if (match && match.index > 0) { return null }\n    if (match && consume !== false) { this.pos += match[0].length }\n    return match\n  }\n};\nStringStream.prototype.current = function (){return this.string.slice(this.start, this.pos)};\nStringStream.prototype.hideFirstChars = function (n, inner) {\n  this.lineStart += n\n  try { return inner() }\n  finally { this.lineStart -= n }\n};\n\n// Compute a style array (an array starting with a mode generation\n// -- for invalidation -- followed by pairs of end positions and\n// style strings), which is used to highlight the tokens on the\n// line.\nfunction highlightLine(cm, line, state, forceToEnd) {\n  // A styles array always starts with a number identifying the\n  // mode/overlays that it is based on (for easy invalidation).\n  var st = [cm.state.modeGen], lineClasses = {}\n  // Compute the base array of styles\n  runMode(cm, line.text, cm.doc.mode, state, function (end, style) { return st.push(end, style); },\n    lineClasses, forceToEnd)\n\n  // Run overlays, adjust style array.\n  var loop = function ( o ) {\n    var overlay = cm.state.overlays[o], i = 1, at = 0\n    runMode(cm, line.text, overlay.mode, true, function (end, style) {\n      var start = i\n      // Ensure there's a token end at the current position, and that i points at it\n      while (at < end) {\n        var i_end = st[i]\n        if (i_end > end)\n          { st.splice(i, 1, end, st[i+1], i_end) }\n        i += 2\n        at = Math.min(end, i_end)\n      }\n      if (!style) { return }\n      if (overlay.opaque) {\n        st.splice(start, i - start, end, \"overlay \" + style)\n        i = start + 2\n      } else {\n        for (; start < i; start += 2) {\n          var cur = st[start+1]\n          st[start+1] = (cur ? cur + \" \" : \"\") + \"overlay \" + style\n        }\n      }\n    }, lineClasses)\n  };\n\n  for (var o = 0; o < cm.state.overlays.length; ++o) loop( o );\n\n  return {styles: st, classes: lineClasses.bgClass || lineClasses.textClass ? lineClasses : null}\n}\n\nfunction getLineStyles(cm, line, updateFrontier) {\n  if (!line.styles || line.styles[0] != cm.state.modeGen) {\n    var state = getStateBefore(cm, lineNo(line))\n    var result = highlightLine(cm, line, line.text.length > cm.options.maxHighlightLength ? copyState(cm.doc.mode, state) : state)\n    line.stateAfter = state\n    line.styles = result.styles\n    if (result.classes) { line.styleClasses = result.classes }\n    else if (line.styleClasses) { line.styleClasses = null }\n    if (updateFrontier === cm.doc.frontier) { cm.doc.frontier++ }\n  }\n  return line.styles\n}\n\nfunction getStateBefore(cm, n, precise) {\n  var doc = cm.doc, display = cm.display\n  if (!doc.mode.startState) { return true }\n  var pos = findStartLine(cm, n, precise), state = pos > doc.first && getLine(doc, pos-1).stateAfter\n  if (!state) { state = startState(doc.mode) }\n  else { state = copyState(doc.mode, state) }\n  doc.iter(pos, n, function (line) {\n    processLine(cm, line.text, state)\n    var save = pos == n - 1 || pos % 5 == 0 || pos >= display.viewFrom && pos < display.viewTo\n    line.stateAfter = save ? copyState(doc.mode, state) : null\n    ++pos\n  })\n  if (precise) { doc.frontier = pos }\n  return state\n}\n\n// Lightweight form of highlight -- proceed over this line and\n// update state, but don't save a style array. Used for lines that\n// aren't currently visible.\nfunction processLine(cm, text, state, startAt) {\n  var mode = cm.doc.mode\n  var stream = new StringStream(text, cm.options.tabSize)\n  stream.start = stream.pos = startAt || 0\n  if (text == \"\") { callBlankLine(mode, state) }\n  while (!stream.eol()) {\n    readToken(mode, stream, state)\n    stream.start = stream.pos\n  }\n}\n\nfunction callBlankLine(mode, state) {\n  if (mode.blankLine) { return mode.blankLine(state) }\n  if (!mode.innerMode) { return }\n  var inner = innerMode(mode, state)\n  if (inner.mode.blankLine) { return inner.mode.blankLine(inner.state) }\n}\n\nfunction readToken(mode, stream, state, inner) {\n  for (var i = 0; i < 10; i++) {\n    if (inner) { inner[0] = innerMode(mode, state).mode }\n    var style = mode.token(stream, state)\n    if (stream.pos > stream.start) { return style }\n  }\n  throw new Error(\"Mode \" + mode.name + \" failed to advance stream.\")\n}\n\n// Utility for getTokenAt and getLineTokens\nfunction takeToken(cm, pos, precise, asArray) {\n  var getObj = function (copy) { return ({\n    start: stream.start, end: stream.pos,\n    string: stream.current(),\n    type: style || null,\n    state: copy ? copyState(doc.mode, state) : state\n  }); }\n\n  var doc = cm.doc, mode = doc.mode, style\n  pos = clipPos(doc, pos)\n  var line = getLine(doc, pos.line), state = getStateBefore(cm, pos.line, precise)\n  var stream = new StringStream(line.text, cm.options.tabSize), tokens\n  if (asArray) { tokens = [] }\n  while ((asArray || stream.pos < pos.ch) && !stream.eol()) {\n    stream.start = stream.pos\n    style = readToken(mode, stream, state)\n    if (asArray) { tokens.push(getObj(true)) }\n  }\n  return asArray ? tokens : getObj()\n}\n\nfunction extractLineClasses(type, output) {\n  if (type) { for (;;) {\n    var lineClass = type.match(/(?:^|\\s+)line-(background-)?(\\S+)/)\n    if (!lineClass) { break }\n    type = type.slice(0, lineClass.index) + type.slice(lineClass.index + lineClass[0].length)\n    var prop = lineClass[1] ? \"bgClass\" : \"textClass\"\n    if (output[prop] == null)\n      { output[prop] = lineClass[2] }\n    else if (!(new RegExp(\"(?:^|\\s)\" + lineClass[2] + \"(?:$|\\s)\")).test(output[prop]))\n      { output[prop] += \" \" + lineClass[2] }\n  } }\n  return type\n}\n\n// Run the given mode's parser over a line, calling f for each token.\nfunction runMode(cm, text, mode, state, f, lineClasses, forceToEnd) {\n  var flattenSpans = mode.flattenSpans\n  if (flattenSpans == null) { flattenSpans = cm.options.flattenSpans }\n  var curStart = 0, curStyle = null\n  var stream = new StringStream(text, cm.options.tabSize), style\n  var inner = cm.options.addModeClass && [null]\n  if (text == \"\") { extractLineClasses(callBlankLine(mode, state), lineClasses) }\n  while (!stream.eol()) {\n    if (stream.pos > cm.options.maxHighlightLength) {\n      flattenSpans = false\n      if (forceToEnd) { processLine(cm, text, state, stream.pos) }\n      stream.pos = text.length\n      style = null\n    } else {\n      style = extractLineClasses(readToken(mode, stream, state, inner), lineClasses)\n    }\n    if (inner) {\n      var mName = inner[0].name\n      if (mName) { style = \"m-\" + (style ? mName + \" \" + style : mName) }\n    }\n    if (!flattenSpans || curStyle != style) {\n      while (curStart < stream.start) {\n        curStart = Math.min(stream.start, curStart + 5000)\n        f(curStart, curStyle)\n      }\n      curStyle = style\n    }\n    stream.start = stream.pos\n  }\n  while (curStart < stream.pos) {\n    // Webkit seems to refuse to render text nodes longer than 57444\n    // characters, and returns inaccurate measurements in nodes\n    // starting around 5000 chars.\n    var pos = Math.min(stream.pos, curStart + 5000)\n    f(pos, curStyle)\n    curStart = pos\n  }\n}\n\n// Finds the line to start with when starting a parse. Tries to\n// find a line with a stateAfter, so that it can start with a\n// valid state. If that fails, it returns the line with the\n// smallest indentation, which tends to need the least context to\n// parse correctly.\nfunction findStartLine(cm, n, precise) {\n  var minindent, minline, doc = cm.doc\n  var lim = precise ? -1 : n - (cm.doc.mode.innerMode ? 1000 : 100)\n  for (var search = n; search > lim; --search) {\n    if (search <= doc.first) { return doc.first }\n    var line = getLine(doc, search - 1)\n    if (line.stateAfter && (!precise || search <= doc.frontier)) { return search }\n    var indented = countColumn(line.text, null, cm.options.tabSize)\n    if (minline == null || minindent > indented) {\n      minline = search - 1\n      minindent = indented\n    }\n  }\n  return minline\n}\n\n// LINE DATA STRUCTURE\n\n// Line objects. These hold state related to a line, including\n// highlighting info (the styles array).\nvar Line = function(text, markedSpans, estimateHeight) {\n  this.text = text\n  attachMarkedSpans(this, markedSpans)\n  this.height = estimateHeight ? estimateHeight(this) : 1\n};\n\nLine.prototype.lineNo = function () { return lineNo(this) };\neventMixin(Line)\n\n// Change the content (text, markers) of a line. Automatically\n// invalidates cached information and tries to re-estimate the\n// line's height.\nfunction updateLine(line, text, markedSpans, estimateHeight) {\n  line.text = text\n  if (line.stateAfter) { line.stateAfter = null }\n  if (line.styles) { line.styles = null }\n  if (line.order != null) { line.order = null }\n  detachMarkedSpans(line)\n  attachMarkedSpans(line, markedSpans)\n  var estHeight = estimateHeight ? estimateHeight(line) : 1\n  if (estHeight != line.height) { updateLineHeight(line, estHeight) }\n}\n\n// Detach a line from the document tree and its markers.\nfunction cleanUpLine(line) {\n  line.parent = null\n  detachMarkedSpans(line)\n}\n\n// Convert a style as returned by a mode (either null, or a string\n// containing one or more styles) to a CSS style. This is cached,\n// and also looks for line-wide styles.\nvar styleToClassCache = {};\nvar styleToClassCacheWithMode = {};\nfunction interpretTokenStyle(style, options) {\n  if (!style || /^\\s*$/.test(style)) { return null }\n  var cache = options.addModeClass ? styleToClassCacheWithMode : styleToClassCache\n  return cache[style] ||\n    (cache[style] = style.replace(/\\S+/g, \"cm-$&\"))\n}\n\n// Render the DOM representation of the text of a line. Also builds\n// up a 'line map', which points at the DOM nodes that represent\n// specific stretches of text, and is used by the measuring code.\n// The returned object contains the DOM node, this map, and\n// information about line-wide styles that were set by the mode.\nfunction buildLineContent(cm, lineView) {\n  // The padding-right forces the element to have a 'border', which\n  // is needed on Webkit to be able to get line-level bounding\n  // rectangles for it (in measureChar).\n  var content = elt(\"span\", null, null, webkit ? \"padding-right: .1px\" : null)\n  var builder = {pre: elt(\"pre\", [content], \"CodeMirror-line\"), content: content,\n                 col: 0, pos: 0, cm: cm,\n                 trailingSpace: false,\n                 splitSpaces: (ie || webkit) && cm.getOption(\"lineWrapping\")}\n  // hide from accessibility tree\n  content.setAttribute(\"role\", \"presentation\")\n  builder.pre.setAttribute(\"role\", \"presentation\")\n  lineView.measure = {}\n\n  // Iterate over the logical lines that make up this visual line.\n  for (var i = 0; i <= (lineView.rest ? lineView.rest.length : 0); i++) {\n    var line = i ? lineView.rest[i - 1] : lineView.line, order = (void 0)\n    builder.pos = 0\n    builder.addToken = buildToken\n    // Optionally wire in some hacks into the token-rendering\n    // algorithm, to deal with browser quirks.\n    if (hasBadBidiRects(cm.display.measure) && (order = getOrder(line)))\n      { builder.addToken = buildTokenBadBidi(builder.addToken, order) }\n    builder.map = []\n    var allowFrontierUpdate = lineView != cm.display.externalMeasured && lineNo(line)\n    insertLineContent(line, builder, getLineStyles(cm, line, allowFrontierUpdate))\n    if (line.styleClasses) {\n      if (line.styleClasses.bgClass)\n        { builder.bgClass = joinClasses(line.styleClasses.bgClass, builder.bgClass || \"\") }\n      if (line.styleClasses.textClass)\n        { builder.textClass = joinClasses(line.styleClasses.textClass, builder.textClass || \"\") }\n    }\n\n    // Ensure at least a single node is present, for measuring.\n    if (builder.map.length == 0)\n      { builder.map.push(0, 0, builder.content.appendChild(zeroWidthElement(cm.display.measure))) }\n\n    // Store the map and a cache object for the current logical line\n    if (i == 0) {\n      lineView.measure.map = builder.map\n      lineView.measure.cache = {}\n    } else {\n      ;(lineView.measure.maps || (lineView.measure.maps = [])).push(builder.map)\n      ;(lineView.measure.caches || (lineView.measure.caches = [])).push({})\n    }\n  }\n\n  // See issue #2901\n  if (webkit) {\n    var last = builder.content.lastChild\n    if (/\\bcm-tab\\b/.test(last.className) || (last.querySelector && last.querySelector(\".cm-tab\")))\n      { builder.content.className = \"cm-tab-wrap-hack\" }\n  }\n\n  signal(cm, \"renderLine\", cm, lineView.line, builder.pre)\n  if (builder.pre.className)\n    { builder.textClass = joinClasses(builder.pre.className, builder.textClass || \"\") }\n\n  return builder\n}\n\nfunction defaultSpecialCharPlaceholder(ch) {\n  var token = elt(\"span\", \"\\u2022\", \"cm-invalidchar\")\n  token.title = \"\\\\u\" + ch.charCodeAt(0).toString(16)\n  token.setAttribute(\"aria-label\", token.title)\n  return token\n}\n\n// Build up the DOM representation for a single token, and add it to\n// the line map. Takes care to render special characters separately.\nfunction buildToken(builder, text, style, startStyle, endStyle, title, css) {\n  if (!text) { return }\n  var displayText = builder.splitSpaces ? splitSpaces(text, builder.trailingSpace) : text\n  var special = builder.cm.state.specialChars, mustWrap = false\n  var content\n  if (!special.test(text)) {\n    builder.col += text.length\n    content = document.createTextNode(displayText)\n    builder.map.push(builder.pos, builder.pos + text.length, content)\n    if (ie && ie_version < 9) { mustWrap = true }\n    builder.pos += text.length\n  } else {\n    content = document.createDocumentFragment()\n    var pos = 0\n    while (true) {\n      special.lastIndex = pos\n      var m = special.exec(text)\n      var skipped = m ? m.index - pos : text.length - pos\n      if (skipped) {\n        var txt = document.createTextNode(displayText.slice(pos, pos + skipped))\n        if (ie && ie_version < 9) { content.appendChild(elt(\"span\", [txt])) }\n        else { content.appendChild(txt) }\n        builder.map.push(builder.pos, builder.pos + skipped, txt)\n        builder.col += skipped\n        builder.pos += skipped\n      }\n      if (!m) { break }\n      pos += skipped + 1\n      var txt$1 = (void 0)\n      if (m[0] == \"\\t\") {\n        var tabSize = builder.cm.options.tabSize, tabWidth = tabSize - builder.col % tabSize\n        txt$1 = content.appendChild(elt(\"span\", spaceStr(tabWidth), \"cm-tab\"))\n        txt$1.setAttribute(\"role\", \"presentation\")\n        txt$1.setAttribute(\"cm-text\", \"\\t\")\n        builder.col += tabWidth\n      } else if (m[0] == \"\\r\" || m[0] == \"\\n\") {\n        txt$1 = content.appendChild(elt(\"span\", m[0] == \"\\r\" ? \"\\u240d\" : \"\\u2424\", \"cm-invalidchar\"))\n        txt$1.setAttribute(\"cm-text\", m[0])\n        builder.col += 1\n      } else {\n        txt$1 = builder.cm.options.specialCharPlaceholder(m[0])\n        txt$1.setAttribute(\"cm-text\", m[0])\n        if (ie && ie_version < 9) { content.appendChild(elt(\"span\", [txt$1])) }\n        else { content.appendChild(txt$1) }\n        builder.col += 1\n      }\n      builder.map.push(builder.pos, builder.pos + 1, txt$1)\n      builder.pos++\n    }\n  }\n  builder.trailingSpace = displayText.charCodeAt(text.length - 1) == 32\n  if (style || startStyle || endStyle || mustWrap || css) {\n    var fullStyle = style || \"\"\n    if (startStyle) { fullStyle += startStyle }\n    if (endStyle) { fullStyle += endStyle }\n    var token = elt(\"span\", [content], fullStyle, css)\n    if (title) { token.title = title }\n    return builder.content.appendChild(token)\n  }\n  builder.content.appendChild(content)\n}\n\nfunction splitSpaces(text, trailingBefore) {\n  if (text.length > 1 && !/  /.test(text)) { return text }\n  var spaceBefore = trailingBefore, result = \"\"\n  for (var i = 0; i < text.length; i++) {\n    var ch = text.charAt(i)\n    if (ch == \" \" && spaceBefore && (i == text.length - 1 || text.charCodeAt(i + 1) == 32))\n      { ch = \"\\u00a0\" }\n    result += ch\n    spaceBefore = ch == \" \"\n  }\n  return result\n}\n\n// Work around nonsense dimensions being reported for stretches of\n// right-to-left text.\nfunction buildTokenBadBidi(inner, order) {\n  return function (builder, text, style, startStyle, endStyle, title, css) {\n    style = style ? style + \" cm-force-border\" : \"cm-force-border\"\n    var start = builder.pos, end = start + text.length\n    for (;;) {\n      // Find the part that overlaps with the start of this text\n      var part = (void 0)\n      for (var i = 0; i < order.length; i++) {\n        part = order[i]\n        if (part.to > start && part.from <= start) { break }\n      }\n      if (part.to >= end) { return inner(builder, text, style, startStyle, endStyle, title, css) }\n      inner(builder, text.slice(0, part.to - start), style, startStyle, null, title, css)\n      startStyle = null\n      text = text.slice(part.to - start)\n      start = part.to\n    }\n  }\n}\n\nfunction buildCollapsedSpan(builder, size, marker, ignoreWidget) {\n  var widget = !ignoreWidget && marker.widgetNode\n  if (widget) { builder.map.push(builder.pos, builder.pos + size, widget) }\n  if (!ignoreWidget && builder.cm.display.input.needsContentAttribute) {\n    if (!widget)\n      { widget = builder.content.appendChild(document.createElement(\"span\")) }\n    widget.setAttribute(\"cm-marker\", marker.id)\n  }\n  if (widget) {\n    builder.cm.display.input.setUneditable(widget)\n    builder.content.appendChild(widget)\n  }\n  builder.pos += size\n  builder.trailingSpace = false\n}\n\n// Outputs a number of spans to make up a line, taking highlighting\n// and marked text into account.\nfunction insertLineContent(line, builder, styles) {\n  var spans = line.markedSpans, allText = line.text, at = 0\n  if (!spans) {\n    for (var i$1 = 1; i$1 < styles.length; i$1+=2)\n      { builder.addToken(builder, allText.slice(at, at = styles[i$1]), interpretTokenStyle(styles[i$1+1], builder.cm.options)) }\n    return\n  }\n\n  var len = allText.length, pos = 0, i = 1, text = \"\", style, css\n  var nextChange = 0, spanStyle, spanEndStyle, spanStartStyle, title, collapsed\n  for (;;) {\n    if (nextChange == pos) { // Update current marker set\n      spanStyle = spanEndStyle = spanStartStyle = title = css = \"\"\n      collapsed = null; nextChange = Infinity\n      var foundBookmarks = [], endStyles = (void 0)\n      for (var j = 0; j < spans.length; ++j) {\n        var sp = spans[j], m = sp.marker\n        if (m.type == \"bookmark\" && sp.from == pos && m.widgetNode) {\n          foundBookmarks.push(m)\n        } else if (sp.from <= pos && (sp.to == null || sp.to > pos || m.collapsed && sp.to == pos && sp.from == pos)) {\n          if (sp.to != null && sp.to != pos && nextChange > sp.to) {\n            nextChange = sp.to\n            spanEndStyle = \"\"\n          }\n          if (m.className) { spanStyle += \" \" + m.className }\n          if (m.css) { css = (css ? css + \";\" : \"\") + m.css }\n          if (m.startStyle && sp.from == pos) { spanStartStyle += \" \" + m.startStyle }\n          if (m.endStyle && sp.to == nextChange) { (endStyles || (endStyles = [])).push(m.endStyle, sp.to) }\n          if (m.title && !title) { title = m.title }\n          if (m.collapsed && (!collapsed || compareCollapsedMarkers(collapsed.marker, m) < 0))\n            { collapsed = sp }\n        } else if (sp.from > pos && nextChange > sp.from) {\n          nextChange = sp.from\n        }\n      }\n      if (endStyles) { for (var j$1 = 0; j$1 < endStyles.length; j$1 += 2)\n        { if (endStyles[j$1 + 1] == nextChange) { spanEndStyle += \" \" + endStyles[j$1] } } }\n\n      if (!collapsed || collapsed.from == pos) { for (var j$2 = 0; j$2 < foundBookmarks.length; ++j$2)\n        { buildCollapsedSpan(builder, 0, foundBookmarks[j$2]) } }\n      if (collapsed && (collapsed.from || 0) == pos) {\n        buildCollapsedSpan(builder, (collapsed.to == null ? len + 1 : collapsed.to) - pos,\n                           collapsed.marker, collapsed.from == null)\n        if (collapsed.to == null) { return }\n        if (collapsed.to == pos) { collapsed = false }\n      }\n    }\n    if (pos >= len) { break }\n\n    var upto = Math.min(len, nextChange)\n    while (true) {\n      if (text) {\n        var end = pos + text.length\n        if (!collapsed) {\n          var tokenText = end > upto ? text.slice(0, upto - pos) : text\n          builder.addToken(builder, tokenText, style ? style + spanStyle : spanStyle,\n                           spanStartStyle, pos + tokenText.length == nextChange ? spanEndStyle : \"\", title, css)\n        }\n        if (end >= upto) {text = text.slice(upto - pos); pos = upto; break}\n        pos = end\n        spanStartStyle = \"\"\n      }\n      text = allText.slice(at, at = styles[i++])\n      style = interpretTokenStyle(styles[i++], builder.cm.options)\n    }\n  }\n}\n\n\n// These objects are used to represent the visible (currently drawn)\n// part of the document. A LineView may correspond to multiple\n// logical lines, if those are connected by collapsed ranges.\nfunction LineView(doc, line, lineN) {\n  // The starting line\n  this.line = line\n  // Continuing lines, if any\n  this.rest = visualLineContinued(line)\n  // Number of logical lines in this visual line\n  this.size = this.rest ? lineNo(lst(this.rest)) - lineN + 1 : 1\n  this.node = this.text = null\n  this.hidden = lineIsHidden(doc, line)\n}\n\n// Create a range of LineView objects for the given lines.\nfunction buildViewArray(cm, from, to) {\n  var array = [], nextPos\n  for (var pos = from; pos < to; pos = nextPos) {\n    var view = new LineView(cm.doc, getLine(cm.doc, pos), pos)\n    nextPos = pos + view.size\n    array.push(view)\n  }\n  return array\n}\n\nvar operationGroup = null\n\nfunction pushOperation(op) {\n  if (operationGroup) {\n    operationGroup.ops.push(op)\n  } else {\n    op.ownsGroup = operationGroup = {\n      ops: [op],\n      delayedCallbacks: []\n    }\n  }\n}\n\nfunction fireCallbacksForOps(group) {\n  // Calls delayed callbacks and cursorActivity handlers until no\n  // new ones appear\n  var callbacks = group.delayedCallbacks, i = 0\n  do {\n    for (; i < callbacks.length; i++)\n      { callbacks[i].call(null) }\n    for (var j = 0; j < group.ops.length; j++) {\n      var op = group.ops[j]\n      if (op.cursorActivityHandlers)\n        { while (op.cursorActivityCalled < op.cursorActivityHandlers.length)\n          { op.cursorActivityHandlers[op.cursorActivityCalled++].call(null, op.cm) } }\n    }\n  } while (i < callbacks.length)\n}\n\nfunction finishOperation(op, endCb) {\n  var group = op.ownsGroup\n  if (!group) { return }\n\n  try { fireCallbacksForOps(group) }\n  finally {\n    operationGroup = null\n    endCb(group)\n  }\n}\n\nvar orphanDelayedCallbacks = null\n\n// Often, we want to signal events at a point where we are in the\n// middle of some work, but don't want the handler to start calling\n// other methods on the editor, which might be in an inconsistent\n// state or simply not expect any other events to happen.\n// signalLater looks whether there are any handlers, and schedules\n// them to be executed when the last operation ends, or, if no\n// operation is active, when a timeout fires.\nfunction signalLater(emitter, type /*, values...*/) {\n  var arr = getHandlers(emitter, type)\n  if (!arr.length) { return }\n  var args = Array.prototype.slice.call(arguments, 2), list\n  if (operationGroup) {\n    list = operationGroup.delayedCallbacks\n  } else if (orphanDelayedCallbacks) {\n    list = orphanDelayedCallbacks\n  } else {\n    list = orphanDelayedCallbacks = []\n    setTimeout(fireOrphanDelayed, 0)\n  }\n  var loop = function ( i ) {\n    list.push(function () { return arr[i].apply(null, args); })\n  };\n\n  for (var i = 0; i < arr.length; ++i)\n    loop( i );\n}\n\nfunction fireOrphanDelayed() {\n  var delayed = orphanDelayedCallbacks\n  orphanDelayedCallbacks = null\n  for (var i = 0; i < delayed.length; ++i) { delayed[i]() }\n}\n\n// When an aspect of a line changes, a string is added to\n// lineView.changes. This updates the relevant part of the line's\n// DOM structure.\nfunction updateLineForChanges(cm, lineView, lineN, dims) {\n  for (var j = 0; j < lineView.changes.length; j++) {\n    var type = lineView.changes[j]\n    if (type == \"text\") { updateLineText(cm, lineView) }\n    else if (type == \"gutter\") { updateLineGutter(cm, lineView, lineN, dims) }\n    else if (type == \"class\") { updateLineClasses(lineView) }\n    else if (type == \"widget\") { updateLineWidgets(cm, lineView, dims) }\n  }\n  lineView.changes = null\n}\n\n// Lines with gutter elements, widgets or a background class need to\n// be wrapped, and have the extra elements added to the wrapper div\nfunction ensureLineWrapped(lineView) {\n  if (lineView.node == lineView.text) {\n    lineView.node = elt(\"div\", null, null, \"position: relative\")\n    if (lineView.text.parentNode)\n      { lineView.text.parentNode.replaceChild(lineView.node, lineView.text) }\n    lineView.node.appendChild(lineView.text)\n    if (ie && ie_version < 8) { lineView.node.style.zIndex = 2 }\n  }\n  return lineView.node\n}\n\nfunction updateLineBackground(lineView) {\n  var cls = lineView.bgClass ? lineView.bgClass + \" \" + (lineView.line.bgClass || \"\") : lineView.line.bgClass\n  if (cls) { cls += \" CodeMirror-linebackground\" }\n  if (lineView.background) {\n    if (cls) { lineView.background.className = cls }\n    else { lineView.background.parentNode.removeChild(lineView.background); lineView.background = null }\n  } else if (cls) {\n    var wrap = ensureLineWrapped(lineView)\n    lineView.background = wrap.insertBefore(elt(\"div\", null, cls), wrap.firstChild)\n  }\n}\n\n// Wrapper around buildLineContent which will reuse the structure\n// in display.externalMeasured when possible.\nfunction getLineContent(cm, lineView) {\n  var ext = cm.display.externalMeasured\n  if (ext && ext.line == lineView.line) {\n    cm.display.externalMeasured = null\n    lineView.measure = ext.measure\n    return ext.built\n  }\n  return buildLineContent(cm, lineView)\n}\n\n// Redraw the line's text. Interacts with the background and text\n// classes because the mode may output tokens that influence these\n// classes.\nfunction updateLineText(cm, lineView) {\n  var cls = lineView.text.className\n  var built = getLineContent(cm, lineView)\n  if (lineView.text == lineView.node) { lineView.node = built.pre }\n  lineView.text.parentNode.replaceChild(built.pre, lineView.text)\n  lineView.text = built.pre\n  if (built.bgClass != lineView.bgClass || built.textClass != lineView.textClass) {\n    lineView.bgClass = built.bgClass\n    lineView.textClass = built.textClass\n    updateLineClasses(lineView)\n  } else if (cls) {\n    lineView.text.className = cls\n  }\n}\n\nfunction updateLineClasses(lineView) {\n  updateLineBackground(lineView)\n  if (lineView.line.wrapClass)\n    { ensureLineWrapped(lineView).className = lineView.line.wrapClass }\n  else if (lineView.node != lineView.text)\n    { lineView.node.className = \"\" }\n  var textClass = lineView.textClass ? lineView.textClass + \" \" + (lineView.line.textClass || \"\") : lineView.line.textClass\n  lineView.text.className = textClass || \"\"\n}\n\nfunction updateLineGutter(cm, lineView, lineN, dims) {\n  if (lineView.gutter) {\n    lineView.node.removeChild(lineView.gutter)\n    lineView.gutter = null\n  }\n  if (lineView.gutterBackground) {\n    lineView.node.removeChild(lineView.gutterBackground)\n    lineView.gutterBackground = null\n  }\n  if (lineView.line.gutterClass) {\n    var wrap = ensureLineWrapped(lineView)\n    lineView.gutterBackground = elt(\"div\", null, \"CodeMirror-gutter-background \" + lineView.line.gutterClass,\n                                    (\"left: \" + (cm.options.fixedGutter ? dims.fixedPos : -dims.gutterTotalWidth) + \"px; width: \" + (dims.gutterTotalWidth) + \"px\"))\n    wrap.insertBefore(lineView.gutterBackground, lineView.text)\n  }\n  var markers = lineView.line.gutterMarkers\n  if (cm.options.lineNumbers || markers) {\n    var wrap$1 = ensureLineWrapped(lineView)\n    var gutterWrap = lineView.gutter = elt(\"div\", null, \"CodeMirror-gutter-wrapper\", (\"left: \" + (cm.options.fixedGutter ? dims.fixedPos : -dims.gutterTotalWidth) + \"px\"))\n    cm.display.input.setUneditable(gutterWrap)\n    wrap$1.insertBefore(gutterWrap, lineView.text)\n    if (lineView.line.gutterClass)\n      { gutterWrap.className += \" \" + lineView.line.gutterClass }\n    if (cm.options.lineNumbers && (!markers || !markers[\"CodeMirror-linenumbers\"]))\n      { lineView.lineNumber = gutterWrap.appendChild(\n        elt(\"div\", lineNumberFor(cm.options, lineN),\n            \"CodeMirror-linenumber CodeMirror-gutter-elt\",\n            (\"left: \" + (dims.gutterLeft[\"CodeMirror-linenumbers\"]) + \"px; width: \" + (cm.display.lineNumInnerWidth) + \"px\"))) }\n    if (markers) { for (var k = 0; k < cm.options.gutters.length; ++k) {\n      var id = cm.options.gutters[k], found = markers.hasOwnProperty(id) && markers[id]\n      if (found)\n        { gutterWrap.appendChild(elt(\"div\", [found], \"CodeMirror-gutter-elt\",\n                                   (\"left: \" + (dims.gutterLeft[id]) + \"px; width: \" + (dims.gutterWidth[id]) + \"px\"))) }\n    } }\n  }\n}\n\nfunction updateLineWidgets(cm, lineView, dims) {\n  if (lineView.alignable) { lineView.alignable = null }\n  for (var node = lineView.node.firstChild, next = (void 0); node; node = next) {\n    next = node.nextSibling\n    if (node.className == \"CodeMirror-linewidget\")\n      { lineView.node.removeChild(node) }\n  }\n  insertLineWidgets(cm, lineView, dims)\n}\n\n// Build a line's DOM representation from scratch\nfunction buildLineElement(cm, lineView, lineN, dims) {\n  var built = getLineContent(cm, lineView)\n  lineView.text = lineView.node = built.pre\n  if (built.bgClass) { lineView.bgClass = built.bgClass }\n  if (built.textClass) { lineView.textClass = built.textClass }\n\n  updateLineClasses(lineView)\n  updateLineGutter(cm, lineView, lineN, dims)\n  insertLineWidgets(cm, lineView, dims)\n  return lineView.node\n}\n\n// A lineView may contain multiple logical lines (when merged by\n// collapsed spans). The widgets for all of them need to be drawn.\nfunction insertLineWidgets(cm, lineView, dims) {\n  insertLineWidgetsFor(cm, lineView.line, lineView, dims, true)\n  if (lineView.rest) { for (var i = 0; i < lineView.rest.length; i++)\n    { insertLineWidgetsFor(cm, lineView.rest[i], lineView, dims, false) } }\n}\n\nfunction insertLineWidgetsFor(cm, line, lineView, dims, allowAbove) {\n  if (!line.widgets) { return }\n  var wrap = ensureLineWrapped(lineView)\n  for (var i = 0, ws = line.widgets; i < ws.length; ++i) {\n    var widget = ws[i], node = elt(\"div\", [widget.node], \"CodeMirror-linewidget\")\n    if (!widget.handleMouseEvents) { node.setAttribute(\"cm-ignore-events\", \"true\") }\n    positionLineWidget(widget, node, lineView, dims)\n    cm.display.input.setUneditable(node)\n    if (allowAbove && widget.above)\n      { wrap.insertBefore(node, lineView.gutter || lineView.text) }\n    else\n      { wrap.appendChild(node) }\n    signalLater(widget, \"redraw\")\n  }\n}\n\nfunction positionLineWidget(widget, node, lineView, dims) {\n  if (widget.noHScroll) {\n    ;(lineView.alignable || (lineView.alignable = [])).push(node)\n    var width = dims.wrapperWidth\n    node.style.left = dims.fixedPos + \"px\"\n    if (!widget.coverGutter) {\n      width -= dims.gutterTotalWidth\n      node.style.paddingLeft = dims.gutterTotalWidth + \"px\"\n    }\n    node.style.width = width + \"px\"\n  }\n  if (widget.coverGutter) {\n    node.style.zIndex = 5\n    node.style.position = \"relative\"\n    if (!widget.noHScroll) { node.style.marginLeft = -dims.gutterTotalWidth + \"px\" }\n  }\n}\n\nfunction widgetHeight(widget) {\n  if (widget.height != null) { return widget.height }\n  var cm = widget.doc.cm\n  if (!cm) { return 0 }\n  if (!contains(document.body, widget.node)) {\n    var parentStyle = \"position: relative;\"\n    if (widget.coverGutter)\n      { parentStyle += \"margin-left: -\" + cm.display.gutters.offsetWidth + \"px;\" }\n    if (widget.noHScroll)\n      { parentStyle += \"width: \" + cm.display.wrapper.clientWidth + \"px;\" }\n    removeChildrenAndAdd(cm.display.measure, elt(\"div\", [widget.node], null, parentStyle))\n  }\n  return widget.height = widget.node.parentNode.offsetHeight\n}\n\n// Return true when the given mouse event happened in a widget\nfunction eventInWidget(display, e) {\n  for (var n = e_target(e); n != display.wrapper; n = n.parentNode) {\n    if (!n || (n.nodeType == 1 && n.getAttribute(\"cm-ignore-events\") == \"true\") ||\n        (n.parentNode == display.sizer && n != display.mover))\n      { return true }\n  }\n}\n\n// POSITION MEASUREMENT\n\nfunction paddingTop(display) {return display.lineSpace.offsetTop}\nfunction paddingVert(display) {return display.mover.offsetHeight - display.lineSpace.offsetHeight}\nfunction paddingH(display) {\n  if (display.cachedPaddingH) { return display.cachedPaddingH }\n  var e = removeChildrenAndAdd(display.measure, elt(\"pre\", \"x\"))\n  var style = window.getComputedStyle ? window.getComputedStyle(e) : e.currentStyle\n  var data = {left: parseInt(style.paddingLeft), right: parseInt(style.paddingRight)}\n  if (!isNaN(data.left) && !isNaN(data.right)) { display.cachedPaddingH = data }\n  return data\n}\n\nfunction scrollGap(cm) { return scrollerGap - cm.display.nativeBarWidth }\nfunction displayWidth(cm) {\n  return cm.display.scroller.clientWidth - scrollGap(cm) - cm.display.barWidth\n}\nfunction displayHeight(cm) {\n  return cm.display.scroller.clientHeight - scrollGap(cm) - cm.display.barHeight\n}\n\n// Ensure the lineView.wrapping.heights array is populated. This is\n// an array of bottom offsets for the lines that make up a drawn\n// line. When lineWrapping is on, there might be more than one\n// height.\nfunction ensureLineHeights(cm, lineView, rect) {\n  var wrapping = cm.options.lineWrapping\n  var curWidth = wrapping && displayWidth(cm)\n  if (!lineView.measure.heights || wrapping && lineView.measure.width != curWidth) {\n    var heights = lineView.measure.heights = []\n    if (wrapping) {\n      lineView.measure.width = curWidth\n      var rects = lineView.text.firstChild.getClientRects()\n      for (var i = 0; i < rects.length - 1; i++) {\n        var cur = rects[i], next = rects[i + 1]\n        if (Math.abs(cur.bottom - next.bottom) > 2)\n          { heights.push((cur.bottom + next.top) / 2 - rect.top) }\n      }\n    }\n    heights.push(rect.bottom - rect.top)\n  }\n}\n\n// Find a line map (mapping character offsets to text nodes) and a\n// measurement cache for the given line number. (A line view might\n// contain multiple lines when collapsed ranges are present.)\nfunction mapFromLineView(lineView, line, lineN) {\n  if (lineView.line == line)\n    { return {map: lineView.measure.map, cache: lineView.measure.cache} }\n  for (var i = 0; i < lineView.rest.length; i++)\n    { if (lineView.rest[i] == line)\n      { return {map: lineView.measure.maps[i], cache: lineView.measure.caches[i]} } }\n  for (var i$1 = 0; i$1 < lineView.rest.length; i$1++)\n    { if (lineNo(lineView.rest[i$1]) > lineN)\n      { return {map: lineView.measure.maps[i$1], cache: lineView.measure.caches[i$1], before: true} } }\n}\n\n// Render a line into the hidden node display.externalMeasured. Used\n// when measurement is needed for a line that's not in the viewport.\nfunction updateExternalMeasurement(cm, line) {\n  line = visualLine(line)\n  var lineN = lineNo(line)\n  var view = cm.display.externalMeasured = new LineView(cm.doc, line, lineN)\n  view.lineN = lineN\n  var built = view.built = buildLineContent(cm, view)\n  view.text = built.pre\n  removeChildrenAndAdd(cm.display.lineMeasure, built.pre)\n  return view\n}\n\n// Get a {top, bottom, left, right} box (in line-local coordinates)\n// for a given character.\nfunction measureChar(cm, line, ch, bias) {\n  return measureCharPrepared(cm, prepareMeasureForLine(cm, line), ch, bias)\n}\n\n// Find a line view that corresponds to the given line number.\nfunction findViewForLine(cm, lineN) {\n  if (lineN >= cm.display.viewFrom && lineN < cm.display.viewTo)\n    { return cm.display.view[findViewIndex(cm, lineN)] }\n  var ext = cm.display.externalMeasured\n  if (ext && lineN >= ext.lineN && lineN < ext.lineN + ext.size)\n    { return ext }\n}\n\n// Measurement can be split in two steps, the set-up work that\n// applies to the whole line, and the measurement of the actual\n// character. Functions like coordsChar, that need to do a lot of\n// measurements in a row, can thus ensure that the set-up work is\n// only done once.\nfunction prepareMeasureForLine(cm, line) {\n  var lineN = lineNo(line)\n  var view = findViewForLine(cm, lineN)\n  if (view && !view.text) {\n    view = null\n  } else if (view && view.changes) {\n    updateLineForChanges(cm, view, lineN, getDimensions(cm))\n    cm.curOp.forceUpdate = true\n  }\n  if (!view)\n    { view = updateExternalMeasurement(cm, line) }\n\n  var info = mapFromLineView(view, line, lineN)\n  return {\n    line: line, view: view, rect: null,\n    map: info.map, cache: info.cache, before: info.before,\n    hasHeights: false\n  }\n}\n\n// Given a prepared measurement object, measures the position of an\n// actual character (or fetches it from the cache).\nfunction measureCharPrepared(cm, prepared, ch, bias, varHeight) {\n  if (prepared.before) { ch = -1 }\n  var key = ch + (bias || \"\"), found\n  if (prepared.cache.hasOwnProperty(key)) {\n    found = prepared.cache[key]\n  } else {\n    if (!prepared.rect)\n      { prepared.rect = prepared.view.text.getBoundingClientRect() }\n    if (!prepared.hasHeights) {\n      ensureLineHeights(cm, prepared.view, prepared.rect)\n      prepared.hasHeights = true\n    }\n    found = measureCharInner(cm, prepared, ch, bias)\n    if (!found.bogus) { prepared.cache[key] = found }\n  }\n  return {left: found.left, right: found.right,\n          top: varHeight ? found.rtop : found.top,\n          bottom: varHeight ? found.rbottom : found.bottom}\n}\n\nvar nullRect = {left: 0, right: 0, top: 0, bottom: 0}\n\nfunction nodeAndOffsetInLineMap(map, ch, bias) {\n  var node, start, end, collapse, mStart, mEnd\n  // First, search the line map for the text node corresponding to,\n  // or closest to, the target character.\n  for (var i = 0; i < map.length; i += 3) {\n    mStart = map[i]\n    mEnd = map[i + 1]\n    if (ch < mStart) {\n      start = 0; end = 1\n      collapse = \"left\"\n    } else if (ch < mEnd) {\n      start = ch - mStart\n      end = start + 1\n    } else if (i == map.length - 3 || ch == mEnd && map[i + 3] > ch) {\n      end = mEnd - mStart\n      start = end - 1\n      if (ch >= mEnd) { collapse = \"right\" }\n    }\n    if (start != null) {\n      node = map[i + 2]\n      if (mStart == mEnd && bias == (node.insertLeft ? \"left\" : \"right\"))\n        { collapse = bias }\n      if (bias == \"left\" && start == 0)\n        { while (i && map[i - 2] == map[i - 3] && map[i - 1].insertLeft) {\n          node = map[(i -= 3) + 2]\n          collapse = \"left\"\n        } }\n      if (bias == \"right\" && start == mEnd - mStart)\n        { while (i < map.length - 3 && map[i + 3] == map[i + 4] && !map[i + 5].insertLeft) {\n          node = map[(i += 3) + 2]\n          collapse = \"right\"\n        } }\n      break\n    }\n  }\n  return {node: node, start: start, end: end, collapse: collapse, coverStart: mStart, coverEnd: mEnd}\n}\n\nfunction getUsefulRect(rects, bias) {\n  var rect = nullRect\n  if (bias == \"left\") { for (var i = 0; i < rects.length; i++) {\n    if ((rect = rects[i]).left != rect.right) { break }\n  } } else { for (var i$1 = rects.length - 1; i$1 >= 0; i$1--) {\n    if ((rect = rects[i$1]).left != rect.right) { break }\n  } }\n  return rect\n}\n\nfunction measureCharInner(cm, prepared, ch, bias) {\n  var place = nodeAndOffsetInLineMap(prepared.map, ch, bias)\n  var node = place.node, start = place.start, end = place.end, collapse = place.collapse\n\n  var rect\n  if (node.nodeType == 3) { // If it is a text node, use a range to retrieve the coordinates.\n    for (var i$1 = 0; i$1 < 4; i$1++) { // Retry a maximum of 4 times when nonsense rectangles are returned\n      while (start && isExtendingChar(prepared.line.text.charAt(place.coverStart + start))) { --start }\n      while (place.coverStart + end < place.coverEnd && isExtendingChar(prepared.line.text.charAt(place.coverStart + end))) { ++end }\n      if (ie && ie_version < 9 && start == 0 && end == place.coverEnd - place.coverStart)\n        { rect = node.parentNode.getBoundingClientRect() }\n      else\n        { rect = getUsefulRect(range(node, start, end).getClientRects(), bias) }\n      if (rect.left || rect.right || start == 0) { break }\n      end = start\n      start = start - 1\n      collapse = \"right\"\n    }\n    if (ie && ie_version < 11) { rect = maybeUpdateRectForZooming(cm.display.measure, rect) }\n  } else { // If it is a widget, simply get the box for the whole widget.\n    if (start > 0) { collapse = bias = \"right\" }\n    var rects\n    if (cm.options.lineWrapping && (rects = node.getClientRects()).length > 1)\n      { rect = rects[bias == \"right\" ? rects.length - 1 : 0] }\n    else\n      { rect = node.getBoundingClientRect() }\n  }\n  if (ie && ie_version < 9 && !start && (!rect || !rect.left && !rect.right)) {\n    var rSpan = node.parentNode.getClientRects()[0]\n    if (rSpan)\n      { rect = {left: rSpan.left, right: rSpan.left + charWidth(cm.display), top: rSpan.top, bottom: rSpan.bottom} }\n    else\n      { rect = nullRect }\n  }\n\n  var rtop = rect.top - prepared.rect.top, rbot = rect.bottom - prepared.rect.top\n  var mid = (rtop + rbot) / 2\n  var heights = prepared.view.measure.heights\n  var i = 0\n  for (; i < heights.length - 1; i++)\n    { if (mid < heights[i]) { break } }\n  var top = i ? heights[i - 1] : 0, bot = heights[i]\n  var result = {left: (collapse == \"right\" ? rect.right : rect.left) - prepared.rect.left,\n                right: (collapse == \"left\" ? rect.left : rect.right) - prepared.rect.left,\n                top: top, bottom: bot}\n  if (!rect.left && !rect.right) { result.bogus = true }\n  if (!cm.options.singleCursorHeightPerLine) { result.rtop = rtop; result.rbottom = rbot }\n\n  return result\n}\n\n// Work around problem with bounding client rects on ranges being\n// returned incorrectly when zoomed on IE10 and below.\nfunction maybeUpdateRectForZooming(measure, rect) {\n  if (!window.screen || screen.logicalXDPI == null ||\n      screen.logicalXDPI == screen.deviceXDPI || !hasBadZoomedRects(measure))\n    { return rect }\n  var scaleX = screen.logicalXDPI / screen.deviceXDPI\n  var scaleY = screen.logicalYDPI / screen.deviceYDPI\n  return {left: rect.left * scaleX, right: rect.right * scaleX,\n          top: rect.top * scaleY, bottom: rect.bottom * scaleY}\n}\n\nfunction clearLineMeasurementCacheFor(lineView) {\n  if (lineView.measure) {\n    lineView.measure.cache = {}\n    lineView.measure.heights = null\n    if (lineView.rest) { for (var i = 0; i < lineView.rest.length; i++)\n      { lineView.measure.caches[i] = {} } }\n  }\n}\n\nfunction clearLineMeasurementCache(cm) {\n  cm.display.externalMeasure = null\n  removeChildren(cm.display.lineMeasure)\n  for (var i = 0; i < cm.display.view.length; i++)\n    { clearLineMeasurementCacheFor(cm.display.view[i]) }\n}\n\nfunction clearCaches(cm) {\n  clearLineMeasurementCache(cm)\n  cm.display.cachedCharWidth = cm.display.cachedTextHeight = cm.display.cachedPaddingH = null\n  if (!cm.options.lineWrapping) { cm.display.maxLineChanged = true }\n  cm.display.lineNumChars = null\n}\n\nfunction pageScrollX() { return window.pageXOffset || (document.documentElement || document.body).scrollLeft }\nfunction pageScrollY() { return window.pageYOffset || (document.documentElement || document.body).scrollTop }\n\n// Converts a {top, bottom, left, right} box from line-local\n// coordinates into another coordinate system. Context may be one of\n// \"line\", \"div\" (display.lineDiv), \"local\"./null (editor), \"window\",\n// or \"page\".\nfunction intoCoordSystem(cm, lineObj, rect, context, includeWidgets) {\n  if (!includeWidgets && lineObj.widgets) { for (var i = 0; i < lineObj.widgets.length; ++i) { if (lineObj.widgets[i].above) {\n    var size = widgetHeight(lineObj.widgets[i])\n    rect.top += size; rect.bottom += size\n  } } }\n  if (context == \"line\") { return rect }\n  if (!context) { context = \"local\" }\n  var yOff = heightAtLine(lineObj)\n  if (context == \"local\") { yOff += paddingTop(cm.display) }\n  else { yOff -= cm.display.viewOffset }\n  if (context == \"page\" || context == \"window\") {\n    var lOff = cm.display.lineSpace.getBoundingClientRect()\n    yOff += lOff.top + (context == \"window\" ? 0 : pageScrollY())\n    var xOff = lOff.left + (context == \"window\" ? 0 : pageScrollX())\n    rect.left += xOff; rect.right += xOff\n  }\n  rect.top += yOff; rect.bottom += yOff\n  return rect\n}\n\n// Coverts a box from \"div\" coords to another coordinate system.\n// Context may be \"window\", \"page\", \"div\", or \"local\"./null.\nfunction fromCoordSystem(cm, coords, context) {\n  if (context == \"div\") { return coords }\n  var left = coords.left, top = coords.top\n  // First move into \"page\" coordinate system\n  if (context == \"page\") {\n    left -= pageScrollX()\n    top -= pageScrollY()\n  } else if (context == \"local\" || !context) {\n    var localBox = cm.display.sizer.getBoundingClientRect()\n    left += localBox.left\n    top += localBox.top\n  }\n\n  var lineSpaceBox = cm.display.lineSpace.getBoundingClientRect()\n  return {left: left - lineSpaceBox.left, top: top - lineSpaceBox.top}\n}\n\nfunction charCoords(cm, pos, context, lineObj, bias) {\n  if (!lineObj) { lineObj = getLine(cm.doc, pos.line) }\n  return intoCoordSystem(cm, lineObj, measureChar(cm, lineObj, pos.ch, bias), context)\n}\n\n// Returns a box for a given cursor position, which may have an\n// 'other' property containing the position of the secondary cursor\n// on a bidi boundary.\n// A cursor Pos(line, char, \"before\") is on the same visual line as `char - 1`\n// and after `char - 1` in writing order of `char - 1`\n// A cursor Pos(line, char, \"after\") is on the same visual line as `char`\n// and before `char` in writing order of `char`\n// Examples (upper-case letters are RTL, lower-case are LTR):\n//     Pos(0, 1, ...)\n//     before   after\n// ab     a|b     a|b\n// aB     a|B     aB|\n// Ab     |Ab     A|b\n// AB     B|A     B|A\n// Every position after the last character on a line is considered to stick\n// to the last character on the line.\nfunction cursorCoords(cm, pos, context, lineObj, preparedMeasure, varHeight) {\n  lineObj = lineObj || getLine(cm.doc, pos.line)\n  if (!preparedMeasure) { preparedMeasure = prepareMeasureForLine(cm, lineObj) }\n  function get(ch, right) {\n    var m = measureCharPrepared(cm, preparedMeasure, ch, right ? \"right\" : \"left\", varHeight)\n    if (right) { m.left = m.right; } else { m.right = m.left }\n    return intoCoordSystem(cm, lineObj, m, context)\n  }\n  var order = getOrder(lineObj), ch = pos.ch, sticky = pos.sticky\n  if (ch >= lineObj.text.length) {\n    ch = lineObj.text.length\n    sticky = \"before\"\n  } else if (ch <= 0) {\n    ch = 0\n    sticky = \"after\"\n  }\n  if (!order) { return get(sticky == \"before\" ? ch - 1 : ch, sticky == \"before\") }\n\n  function getBidi(ch, partPos, invert) {\n    var part = order[partPos], right = (part.level % 2) != 0\n    return get(invert ? ch - 1 : ch, right != invert)\n  }\n  var partPos = getBidiPartAt(order, ch, sticky)\n  var other = bidiOther\n  var val = getBidi(ch, partPos, sticky == \"before\")\n  if (other != null) { val.other = getBidi(ch, other, sticky != \"before\") }\n  return val\n}\n\n// Used to cheaply estimate the coordinates for a position. Used for\n// intermediate scroll updates.\nfunction estimateCoords(cm, pos) {\n  var left = 0\n  pos = clipPos(cm.doc, pos)\n  if (!cm.options.lineWrapping) { left = charWidth(cm.display) * pos.ch }\n  var lineObj = getLine(cm.doc, pos.line)\n  var top = heightAtLine(lineObj) + paddingTop(cm.display)\n  return {left: left, right: left, top: top, bottom: top + lineObj.height}\n}\n\n// Positions returned by coordsChar contain some extra information.\n// xRel is the relative x position of the input coordinates compared\n// to the found position (so xRel > 0 means the coordinates are to\n// the right of the character position, for example). When outside\n// is true, that means the coordinates lie outside the line's\n// vertical range.\nfunction PosWithInfo(line, ch, sticky, outside, xRel) {\n  var pos = Pos(line, ch, sticky)\n  pos.xRel = xRel\n  if (outside) { pos.outside = true }\n  return pos\n}\n\n// Compute the character position closest to the given coordinates.\n// Input must be lineSpace-local (\"div\" coordinate system).\nfunction coordsChar(cm, x, y) {\n  var doc = cm.doc\n  y += cm.display.viewOffset\n  if (y < 0) { return PosWithInfo(doc.first, 0, null, true, -1) }\n  var lineN = lineAtHeight(doc, y), last = doc.first + doc.size - 1\n  if (lineN > last)\n    { return PosWithInfo(doc.first + doc.size - 1, getLine(doc, last).text.length, null, true, 1) }\n  if (x < 0) { x = 0 }\n\n  var lineObj = getLine(doc, lineN)\n  for (;;) {\n    var found = coordsCharInner(cm, lineObj, lineN, x, y)\n    var merged = collapsedSpanAtEnd(lineObj)\n    var mergedPos = merged && merged.find(0, true)\n    if (merged && (found.ch > mergedPos.from.ch || found.ch == mergedPos.from.ch && found.xRel > 0))\n      { lineN = lineNo(lineObj = mergedPos.to.line) }\n    else\n      { return found }\n  }\n}\n\nfunction wrappedLineExtent(cm, lineObj, preparedMeasure, y) {\n  var measure = function (ch) { return intoCoordSystem(cm, lineObj, measureCharPrepared(cm, preparedMeasure, ch), \"line\"); }\n  var end = lineObj.text.length\n  var begin = findFirst(function (ch) { return measure(ch - 1).bottom <= y; }, end, 0)\n  end = findFirst(function (ch) { return measure(ch).top > y; }, begin, end)\n  return {begin: begin, end: end}\n}\n\nfunction wrappedLineExtentChar(cm, lineObj, preparedMeasure, target) {\n  var targetTop = intoCoordSystem(cm, lineObj, measureCharPrepared(cm, preparedMeasure, target), \"line\").top\n  return wrappedLineExtent(cm, lineObj, preparedMeasure, targetTop)\n}\n\nfunction coordsCharInner(cm, lineObj, lineNo, x, y) {\n  y -= heightAtLine(lineObj)\n  var begin = 0, end = lineObj.text.length\n  var preparedMeasure = prepareMeasureForLine(cm, lineObj)\n  var pos\n  var order = getOrder(lineObj)\n  if (order) {\n    if (cm.options.lineWrapping) {\n      ;var assign;\n      ((assign = wrappedLineExtent(cm, lineObj, preparedMeasure, y), begin = assign.begin, end = assign.end, assign))\n    }\n    pos = new Pos(lineNo, begin)\n    var beginLeft = cursorCoords(cm, pos, \"line\", lineObj, preparedMeasure).left\n    var dir = beginLeft < x ? 1 : -1\n    var prevDiff, diff = beginLeft - x, prevPos\n    do {\n      prevDiff = diff\n      prevPos = pos\n      pos = moveVisually(cm, lineObj, pos, dir)\n      if (pos == null || pos.ch < begin || end <= (pos.sticky == \"before\" ? pos.ch - 1 : pos.ch)) {\n        pos = prevPos\n        break\n      }\n      diff = cursorCoords(cm, pos, \"line\", lineObj, preparedMeasure).left - x\n    } while ((dir < 0) != (diff < 0) && (Math.abs(diff) <= Math.abs(prevDiff)))\n    if (Math.abs(diff) > Math.abs(prevDiff)) {\n      if ((diff < 0) == (prevDiff < 0)) { throw new Error(\"Broke out of infinite loop in coordsCharInner\") }\n      pos = prevPos\n    }\n  } else {\n    var ch = findFirst(function (ch) {\n      var box = intoCoordSystem(cm, lineObj, measureCharPrepared(cm, preparedMeasure, ch), \"line\")\n      if (box.top > y) {\n        // For the cursor stickiness\n        end = Math.min(ch, end)\n        return true\n      }\n      else if (box.bottom <= y) { return false }\n      else if (box.left > x) { return true }\n      else if (box.right < x) { return false }\n      else { return (x - box.left < box.right - x) }\n    }, begin, end)\n    ch = skipExtendingChars(lineObj.text, ch, 1)\n    pos = new Pos(lineNo, ch, ch == end ? \"before\" : \"after\")\n  }\n  var coords = cursorCoords(cm, pos, \"line\", lineObj, preparedMeasure)\n  if (y < coords.top || coords.bottom < y) { pos.outside = true }\n  pos.xRel = x < coords.left ? -1 : (x > coords.right ? 1 : 0)\n  return pos\n}\n\nvar measureText\n// Compute the default text height.\nfunction textHeight(display) {\n  if (display.cachedTextHeight != null) { return display.cachedTextHeight }\n  if (measureText == null) {\n    measureText = elt(\"pre\")\n    // Measure a bunch of lines, for browsers that compute\n    // fractional heights.\n    for (var i = 0; i < 49; ++i) {\n      measureText.appendChild(document.createTextNode(\"x\"))\n      measureText.appendChild(elt(\"br\"))\n    }\n    measureText.appendChild(document.createTextNode(\"x\"))\n  }\n  removeChildrenAndAdd(display.measure, measureText)\n  var height = measureText.offsetHeight / 50\n  if (height > 3) { display.cachedTextHeight = height }\n  removeChildren(display.measure)\n  return height || 1\n}\n\n// Compute the default character width.\nfunction charWidth(display) {\n  if (display.cachedCharWidth != null) { return display.cachedCharWidth }\n  var anchor = elt(\"span\", \"xxxxxxxxxx\")\n  var pre = elt(\"pre\", [anchor])\n  removeChildrenAndAdd(display.measure, pre)\n  var rect = anchor.getBoundingClientRect(), width = (rect.right - rect.left) / 10\n  if (width > 2) { display.cachedCharWidth = width }\n  return width || 10\n}\n\n// Do a bulk-read of the DOM positions and sizes needed to draw the\n// view, so that we don't interleave reading and writing to the DOM.\nfunction getDimensions(cm) {\n  var d = cm.display, left = {}, width = {}\n  var gutterLeft = d.gutters.clientLeft\n  for (var n = d.gutters.firstChild, i = 0; n; n = n.nextSibling, ++i) {\n    left[cm.options.gutters[i]] = n.offsetLeft + n.clientLeft + gutterLeft\n    width[cm.options.gutters[i]] = n.clientWidth\n  }\n  return {fixedPos: compensateForHScroll(d),\n          gutterTotalWidth: d.gutters.offsetWidth,\n          gutterLeft: left,\n          gutterWidth: width,\n          wrapperWidth: d.wrapper.clientWidth}\n}\n\n// Computes display.scroller.scrollLeft + display.gutters.offsetWidth,\n// but using getBoundingClientRect to get a sub-pixel-accurate\n// result.\nfunction compensateForHScroll(display) {\n  return display.scroller.getBoundingClientRect().left - display.sizer.getBoundingClientRect().left\n}\n\n// Returns a function that estimates the height of a line, to use as\n// first approximation until the line becomes visible (and is thus\n// properly measurable).\nfunction estimateHeight(cm) {\n  var th = textHeight(cm.display), wrapping = cm.options.lineWrapping\n  var perLine = wrapping && Math.max(5, cm.display.scroller.clientWidth / charWidth(cm.display) - 3)\n  return function (line) {\n    if (lineIsHidden(cm.doc, line)) { return 0 }\n\n    var widgetsHeight = 0\n    if (line.widgets) { for (var i = 0; i < line.widgets.length; i++) {\n      if (line.widgets[i].height) { widgetsHeight += line.widgets[i].height }\n    } }\n\n    if (wrapping)\n      { return widgetsHeight + (Math.ceil(line.text.length / perLine) || 1) * th }\n    else\n      { return widgetsHeight + th }\n  }\n}\n\nfunction estimateLineHeights(cm) {\n  var doc = cm.doc, est = estimateHeight(cm)\n  doc.iter(function (line) {\n    var estHeight = est(line)\n    if (estHeight != line.height) { updateLineHeight(line, estHeight) }\n  })\n}\n\n// Given a mouse event, find the corresponding position. If liberal\n// is false, it checks whether a gutter or scrollbar was clicked,\n// and returns null if it was. forRect is used by rectangular\n// selections, and tries to estimate a character position even for\n// coordinates beyond the right of the text.\nfunction posFromMouse(cm, e, liberal, forRect) {\n  var display = cm.display\n  if (!liberal && e_target(e).getAttribute(\"cm-not-content\") == \"true\") { return null }\n\n  var x, y, space = display.lineSpace.getBoundingClientRect()\n  // Fails unpredictably on IE[67] when mouse is dragged around quickly.\n  try { x = e.clientX - space.left; y = e.clientY - space.top }\n  catch (e) { return null }\n  var coords = coordsChar(cm, x, y), line\n  if (forRect && coords.xRel == 1 && (line = getLine(cm.doc, coords.line).text).length == coords.ch) {\n    var colDiff = countColumn(line, line.length, cm.options.tabSize) - line.length\n    coords = Pos(coords.line, Math.max(0, Math.round((x - paddingH(cm.display).left) / charWidth(cm.display)) - colDiff))\n  }\n  return coords\n}\n\n// Find the view element corresponding to a given line. Return null\n// when the line isn't visible.\nfunction findViewIndex(cm, n) {\n  if (n >= cm.display.viewTo) { return null }\n  n -= cm.display.viewFrom\n  if (n < 0) { return null }\n  var view = cm.display.view\n  for (var i = 0; i < view.length; i++) {\n    n -= view[i].size\n    if (n < 0) { return i }\n  }\n}\n\nfunction updateSelection(cm) {\n  cm.display.input.showSelection(cm.display.input.prepareSelection())\n}\n\nfunction prepareSelection(cm, primary) {\n  var doc = cm.doc, result = {}\n  var curFragment = result.cursors = document.createDocumentFragment()\n  var selFragment = result.selection = document.createDocumentFragment()\n\n  for (var i = 0; i < doc.sel.ranges.length; i++) {\n    if (primary === false && i == doc.sel.primIndex) { continue }\n    var range = doc.sel.ranges[i]\n    if (range.from().line >= cm.display.viewTo || range.to().line < cm.display.viewFrom) { continue }\n    var collapsed = range.empty()\n    if (collapsed || cm.options.showCursorWhenSelecting)\n      { drawSelectionCursor(cm, range.head, curFragment) }\n    if (!collapsed)\n      { drawSelectionRange(cm, range, selFragment) }\n  }\n  return result\n}\n\n// Draws a cursor for the given range\nfunction drawSelectionCursor(cm, head, output) {\n  var pos = cursorCoords(cm, head, \"div\", null, null, !cm.options.singleCursorHeightPerLine)\n\n  var cursor = output.appendChild(elt(\"div\", \"\\u00a0\", \"CodeMirror-cursor\"))\n  cursor.style.left = pos.left + \"px\"\n  cursor.style.top = pos.top + \"px\"\n  cursor.style.height = Math.max(0, pos.bottom - pos.top) * cm.options.cursorHeight + \"px\"\n\n  if (pos.other) {\n    // Secondary cursor, shown when on a 'jump' in bi-directional text\n    var otherCursor = output.appendChild(elt(\"div\", \"\\u00a0\", \"CodeMirror-cursor CodeMirror-secondarycursor\"))\n    otherCursor.style.display = \"\"\n    otherCursor.style.left = pos.other.left + \"px\"\n    otherCursor.style.top = pos.other.top + \"px\"\n    otherCursor.style.height = (pos.other.bottom - pos.other.top) * .85 + \"px\"\n  }\n}\n\n// Draws the given range as a highlighted selection\nfunction drawSelectionRange(cm, range, output) {\n  var display = cm.display, doc = cm.doc\n  var fragment = document.createDocumentFragment()\n  var padding = paddingH(cm.display), leftSide = padding.left\n  var rightSide = Math.max(display.sizerWidth, displayWidth(cm) - display.sizer.offsetLeft) - padding.right\n\n  function add(left, top, width, bottom) {\n    if (top < 0) { top = 0 }\n    top = Math.round(top)\n    bottom = Math.round(bottom)\n    fragment.appendChild(elt(\"div\", null, \"CodeMirror-selected\", (\"position: absolute; left: \" + left + \"px;\\n                             top: \" + top + \"px; width: \" + (width == null ? rightSide - left : width) + \"px;\\n                             height: \" + (bottom - top) + \"px\")))\n  }\n\n  function drawForLine(line, fromArg, toArg) {\n    var lineObj = getLine(doc, line)\n    var lineLen = lineObj.text.length\n    var start, end\n    function coords(ch, bias) {\n      return charCoords(cm, Pos(line, ch), \"div\", lineObj, bias)\n    }\n\n    iterateBidiSections(getOrder(lineObj), fromArg || 0, toArg == null ? lineLen : toArg, function (from, to, dir) {\n      var leftPos = coords(from, \"left\"), rightPos, left, right\n      if (from == to) {\n        rightPos = leftPos\n        left = right = leftPos.left\n      } else {\n        rightPos = coords(to - 1, \"right\")\n        if (dir == \"rtl\") { var tmp = leftPos; leftPos = rightPos; rightPos = tmp }\n        left = leftPos.left\n        right = rightPos.right\n      }\n      if (fromArg == null && from == 0) { left = leftSide }\n      if (rightPos.top - leftPos.top > 3) { // Different lines, draw top part\n        add(left, leftPos.top, null, leftPos.bottom)\n        left = leftSide\n        if (leftPos.bottom < rightPos.top) { add(left, leftPos.bottom, null, rightPos.top) }\n      }\n      if (toArg == null && to == lineLen) { right = rightSide }\n      if (!start || leftPos.top < start.top || leftPos.top == start.top && leftPos.left < start.left)\n        { start = leftPos }\n      if (!end || rightPos.bottom > end.bottom || rightPos.bottom == end.bottom && rightPos.right > end.right)\n        { end = rightPos }\n      if (left < leftSide + 1) { left = leftSide }\n      add(left, rightPos.top, right - left, rightPos.bottom)\n    })\n    return {start: start, end: end}\n  }\n\n  var sFrom = range.from(), sTo = range.to()\n  if (sFrom.line == sTo.line) {\n    drawForLine(sFrom.line, sFrom.ch, sTo.ch)\n  } else {\n    var fromLine = getLine(doc, sFrom.line), toLine = getLine(doc, sTo.line)\n    var singleVLine = visualLine(fromLine) == visualLine(toLine)\n    var leftEnd = drawForLine(sFrom.line, sFrom.ch, singleVLine ? fromLine.text.length + 1 : null).end\n    var rightStart = drawForLine(sTo.line, singleVLine ? 0 : null, sTo.ch).start\n    if (singleVLine) {\n      if (leftEnd.top < rightStart.top - 2) {\n        add(leftEnd.right, leftEnd.top, null, leftEnd.bottom)\n        add(leftSide, rightStart.top, rightStart.left, rightStart.bottom)\n      } else {\n        add(leftEnd.right, leftEnd.top, rightStart.left - leftEnd.right, leftEnd.bottom)\n      }\n    }\n    if (leftEnd.bottom < rightStart.top)\n      { add(leftSide, leftEnd.bottom, null, rightStart.top) }\n  }\n\n  output.appendChild(fragment)\n}\n\n// Cursor-blinking\nfunction restartBlink(cm) {\n  if (!cm.state.focused) { return }\n  var display = cm.display\n  clearInterval(display.blinker)\n  var on = true\n  display.cursorDiv.style.visibility = \"\"\n  if (cm.options.cursorBlinkRate > 0)\n    { display.blinker = setInterval(function () { return display.cursorDiv.style.visibility = (on = !on) ? \"\" : \"hidden\"; },\n      cm.options.cursorBlinkRate) }\n  else if (cm.options.cursorBlinkRate < 0)\n    { display.cursorDiv.style.visibility = \"hidden\" }\n}\n\nfunction ensureFocus(cm) {\n  if (!cm.state.focused) { cm.display.input.focus(); onFocus(cm) }\n}\n\nfunction delayBlurEvent(cm) {\n  cm.state.delayingBlurEvent = true\n  setTimeout(function () { if (cm.state.delayingBlurEvent) {\n    cm.state.delayingBlurEvent = false\n    onBlur(cm)\n  } }, 100)\n}\n\nfunction onFocus(cm, e) {\n  if (cm.state.delayingBlurEvent) { cm.state.delayingBlurEvent = false }\n\n  if (cm.options.readOnly == \"nocursor\") { return }\n  if (!cm.state.focused) {\n    signal(cm, \"focus\", cm, e)\n    cm.state.focused = true\n    addClass(cm.display.wrapper, \"CodeMirror-focused\")\n    // This test prevents this from firing when a context\n    // menu is closed (since the input reset would kill the\n    // select-all detection hack)\n    if (!cm.curOp && cm.display.selForContextMenu != cm.doc.sel) {\n      cm.display.input.reset()\n      if (webkit) { setTimeout(function () { return cm.display.input.reset(true); }, 20) } // Issue #1730\n    }\n    cm.display.input.receivedFocus()\n  }\n  restartBlink(cm)\n}\nfunction onBlur(cm, e) {\n  if (cm.state.delayingBlurEvent) { return }\n\n  if (cm.state.focused) {\n    signal(cm, \"blur\", cm, e)\n    cm.state.focused = false\n    rmClass(cm.display.wrapper, \"CodeMirror-focused\")\n  }\n  clearInterval(cm.display.blinker)\n  setTimeout(function () { if (!cm.state.focused) { cm.display.shift = false } }, 150)\n}\n\n// Re-align line numbers and gutter marks to compensate for\n// horizontal scrolling.\nfunction alignHorizontally(cm) {\n  var display = cm.display, view = display.view\n  if (!display.alignWidgets && (!display.gutters.firstChild || !cm.options.fixedGutter)) { return }\n  var comp = compensateForHScroll(display) - display.scroller.scrollLeft + cm.doc.scrollLeft\n  var gutterW = display.gutters.offsetWidth, left = comp + \"px\"\n  for (var i = 0; i < view.length; i++) { if (!view[i].hidden) {\n    if (cm.options.fixedGutter) {\n      if (view[i].gutter)\n        { view[i].gutter.style.left = left }\n      if (view[i].gutterBackground)\n        { view[i].gutterBackground.style.left = left }\n    }\n    var align = view[i].alignable\n    if (align) { for (var j = 0; j < align.length; j++)\n      { align[j].style.left = left } }\n  } }\n  if (cm.options.fixedGutter)\n    { display.gutters.style.left = (comp + gutterW) + \"px\" }\n}\n\n// Used to ensure that the line number gutter is still the right\n// size for the current document size. Returns true when an update\n// is needed.\nfunction maybeUpdateLineNumberWidth(cm) {\n  if (!cm.options.lineNumbers) { return false }\n  var doc = cm.doc, last = lineNumberFor(cm.options, doc.first + doc.size - 1), display = cm.display\n  if (last.length != display.lineNumChars) {\n    var test = display.measure.appendChild(elt(\"div\", [elt(\"div\", last)],\n                                               \"CodeMirror-linenumber CodeMirror-gutter-elt\"))\n    var innerW = test.firstChild.offsetWidth, padding = test.offsetWidth - innerW\n    display.lineGutter.style.width = \"\"\n    display.lineNumInnerWidth = Math.max(innerW, display.lineGutter.offsetWidth - padding) + 1\n    display.lineNumWidth = display.lineNumInnerWidth + padding\n    display.lineNumChars = display.lineNumInnerWidth ? last.length : -1\n    display.lineGutter.style.width = display.lineNumWidth + \"px\"\n    updateGutterSpace(cm)\n    return true\n  }\n  return false\n}\n\n// Read the actual heights of the rendered lines, and update their\n// stored heights to match.\nfunction updateHeightsInViewport(cm) {\n  var display = cm.display\n  var prevBottom = display.lineDiv.offsetTop\n  for (var i = 0; i < display.view.length; i++) {\n    var cur = display.view[i], height = (void 0)\n    if (cur.hidden) { continue }\n    if (ie && ie_version < 8) {\n      var bot = cur.node.offsetTop + cur.node.offsetHeight\n      height = bot - prevBottom\n      prevBottom = bot\n    } else {\n      var box = cur.node.getBoundingClientRect()\n      height = box.bottom - box.top\n    }\n    var diff = cur.line.height - height\n    if (height < 2) { height = textHeight(display) }\n    if (diff > .001 || diff < -.001) {\n      updateLineHeight(cur.line, height)\n      updateWidgetHeight(cur.line)\n      if (cur.rest) { for (var j = 0; j < cur.rest.length; j++)\n        { updateWidgetHeight(cur.rest[j]) } }\n    }\n  }\n}\n\n// Read and store the height of line widgets associated with the\n// given line.\nfunction updateWidgetHeight(line) {\n  if (line.widgets) { for (var i = 0; i < line.widgets.length; ++i)\n    { line.widgets[i].height = line.widgets[i].node.parentNode.offsetHeight } }\n}\n\n// Compute the lines that are visible in a given viewport (defaults\n// the the current scroll position). viewport may contain top,\n// height, and ensure (see op.scrollToPos) properties.\nfunction visibleLines(display, doc, viewport) {\n  var top = viewport && viewport.top != null ? Math.max(0, viewport.top) : display.scroller.scrollTop\n  top = Math.floor(top - paddingTop(display))\n  var bottom = viewport && viewport.bottom != null ? viewport.bottom : top + display.wrapper.clientHeight\n\n  var from = lineAtHeight(doc, top), to = lineAtHeight(doc, bottom)\n  // Ensure is a {from: {line, ch}, to: {line, ch}} object, and\n  // forces those lines into the viewport (if possible).\n  if (viewport && viewport.ensure) {\n    var ensureFrom = viewport.ensure.from.line, ensureTo = viewport.ensure.to.line\n    if (ensureFrom < from) {\n      from = ensureFrom\n      to = lineAtHeight(doc, heightAtLine(getLine(doc, ensureFrom)) + display.wrapper.clientHeight)\n    } else if (Math.min(ensureTo, doc.lastLine()) >= to) {\n      from = lineAtHeight(doc, heightAtLine(getLine(doc, ensureTo)) - display.wrapper.clientHeight)\n      to = ensureTo\n    }\n  }\n  return {from: from, to: Math.max(to, from + 1)}\n}\n\n// Sync the scrollable area and scrollbars, ensure the viewport\n// covers the visible area.\nfunction setScrollTop(cm, val) {\n  if (Math.abs(cm.doc.scrollTop - val) < 2) { return }\n  cm.doc.scrollTop = val\n  if (!gecko) { updateDisplaySimple(cm, {top: val}) }\n  if (cm.display.scroller.scrollTop != val) { cm.display.scroller.scrollTop = val }\n  cm.display.scrollbars.setScrollTop(val)\n  if (gecko) { updateDisplaySimple(cm) }\n  startWorker(cm, 100)\n}\n// Sync scroller and scrollbar, ensure the gutter elements are\n// aligned.\nfunction setScrollLeft(cm, val, isScroller) {\n  if (isScroller ? val == cm.doc.scrollLeft : Math.abs(cm.doc.scrollLeft - val) < 2) { return }\n  val = Math.min(val, cm.display.scroller.scrollWidth - cm.display.scroller.clientWidth)\n  cm.doc.scrollLeft = val\n  alignHorizontally(cm)\n  if (cm.display.scroller.scrollLeft != val) { cm.display.scroller.scrollLeft = val }\n  cm.display.scrollbars.setScrollLeft(val)\n}\n\n// Since the delta values reported on mouse wheel events are\n// unstandardized between browsers and even browser versions, and\n// generally horribly unpredictable, this code starts by measuring\n// the scroll effect that the first few mouse wheel events have,\n// and, from that, detects the way it can convert deltas to pixel\n// offsets afterwards.\n//\n// The reason we want to know the amount a wheel event will scroll\n// is that it gives us a chance to update the display before the\n// actual scrolling happens, reducing flickering.\n\nvar wheelSamples = 0;\nvar wheelPixelsPerUnit = null;\n// Fill in a browser-detected starting value on browsers where we\n// know one. These don't have to be accurate -- the result of them\n// being wrong would just be a slight flicker on the first wheel\n// scroll (if it is large enough).\nif (ie) { wheelPixelsPerUnit = -.53 }\nelse if (gecko) { wheelPixelsPerUnit = 15 }\nelse if (chrome) { wheelPixelsPerUnit = -.7 }\nelse if (safari) { wheelPixelsPerUnit = -1/3 }\n\nfunction wheelEventDelta(e) {\n  var dx = e.wheelDeltaX, dy = e.wheelDeltaY\n  if (dx == null && e.detail && e.axis == e.HORIZONTAL_AXIS) { dx = e.detail }\n  if (dy == null && e.detail && e.axis == e.VERTICAL_AXIS) { dy = e.detail }\n  else if (dy == null) { dy = e.wheelDelta }\n  return {x: dx, y: dy}\n}\nfunction wheelEventPixels(e) {\n  var delta = wheelEventDelta(e)\n  delta.x *= wheelPixelsPerUnit\n  delta.y *= wheelPixelsPerUnit\n  return delta\n}\n\nfunction onScrollWheel(cm, e) {\n  var delta = wheelEventDelta(e), dx = delta.x, dy = delta.y\n\n  var display = cm.display, scroll = display.scroller\n  // Quit if there's nothing to scroll here\n  var canScrollX = scroll.scrollWidth > scroll.clientWidth\n  var canScrollY = scroll.scrollHeight > scroll.clientHeight\n  if (!(dx && canScrollX || dy && canScrollY)) { return }\n\n  // Webkit browsers on OS X abort momentum scrolls when the target\n  // of the scroll event is removed from the scrollable element.\n  // This hack (see related code in patchDisplay) makes sure the\n  // element is kept around.\n  if (dy && mac && webkit) {\n    outer: for (var cur = e.target, view = display.view; cur != scroll; cur = cur.parentNode) {\n      for (var i = 0; i < view.length; i++) {\n        if (view[i].node == cur) {\n          cm.display.currentWheelTarget = cur\n          break outer\n        }\n      }\n    }\n  }\n\n  // On some browsers, horizontal scrolling will cause redraws to\n  // happen before the gutter has been realigned, causing it to\n  // wriggle around in a most unseemly way. When we have an\n  // estimated pixels/delta value, we just handle horizontal\n  // scrolling entirely here. It'll be slightly off from native, but\n  // better than glitching out.\n  if (dx && !gecko && !presto && wheelPixelsPerUnit != null) {\n    if (dy && canScrollY)\n      { setScrollTop(cm, Math.max(0, Math.min(scroll.scrollTop + dy * wheelPixelsPerUnit, scroll.scrollHeight - scroll.clientHeight))) }\n    setScrollLeft(cm, Math.max(0, Math.min(scroll.scrollLeft + dx * wheelPixelsPerUnit, scroll.scrollWidth - scroll.clientWidth)))\n    // Only prevent default scrolling if vertical scrolling is\n    // actually possible. Otherwise, it causes vertical scroll\n    // jitter on OSX trackpads when deltaX is small and deltaY\n    // is large (issue #3579)\n    if (!dy || (dy && canScrollY))\n      { e_preventDefault(e) }\n    display.wheelStartX = null // Abort measurement, if in progress\n    return\n  }\n\n  // 'Project' the visible viewport to cover the area that is being\n  // scrolled into view (if we know enough to estimate it).\n  if (dy && wheelPixelsPerUnit != null) {\n    var pixels = dy * wheelPixelsPerUnit\n    var top = cm.doc.scrollTop, bot = top + display.wrapper.clientHeight\n    if (pixels < 0) { top = Math.max(0, top + pixels - 50) }\n    else { bot = Math.min(cm.doc.height, bot + pixels + 50) }\n    updateDisplaySimple(cm, {top: top, bottom: bot})\n  }\n\n  if (wheelSamples < 20) {\n    if (display.wheelStartX == null) {\n      display.wheelStartX = scroll.scrollLeft; display.wheelStartY = scroll.scrollTop\n      display.wheelDX = dx; display.wheelDY = dy\n      setTimeout(function () {\n        if (display.wheelStartX == null) { return }\n        var movedX = scroll.scrollLeft - display.wheelStartX\n        var movedY = scroll.scrollTop - display.wheelStartY\n        var sample = (movedY && display.wheelDY && movedY / display.wheelDY) ||\n          (movedX && display.wheelDX && movedX / display.wheelDX)\n        display.wheelStartX = display.wheelStartY = null\n        if (!sample) { return }\n        wheelPixelsPerUnit = (wheelPixelsPerUnit * wheelSamples + sample) / (wheelSamples + 1)\n        ++wheelSamples\n      }, 200)\n    } else {\n      display.wheelDX += dx; display.wheelDY += dy\n    }\n  }\n}\n\n// SCROLLBARS\n\n// Prepare DOM reads needed to update the scrollbars. Done in one\n// shot to minimize update/measure roundtrips.\nfunction measureForScrollbars(cm) {\n  var d = cm.display, gutterW = d.gutters.offsetWidth\n  var docH = Math.round(cm.doc.height + paddingVert(cm.display))\n  return {\n    clientHeight: d.scroller.clientHeight,\n    viewHeight: d.wrapper.clientHeight,\n    scrollWidth: d.scroller.scrollWidth, clientWidth: d.scroller.clientWidth,\n    viewWidth: d.wrapper.clientWidth,\n    barLeft: cm.options.fixedGutter ? gutterW : 0,\n    docHeight: docH,\n    scrollHeight: docH + scrollGap(cm) + d.barHeight,\n    nativeBarWidth: d.nativeBarWidth,\n    gutterWidth: gutterW\n  }\n}\n\nvar NativeScrollbars = function(place, scroll, cm) {\n  this.cm = cm\n  var vert = this.vert = elt(\"div\", [elt(\"div\", null, null, \"min-width: 1px\")], \"CodeMirror-vscrollbar\")\n  var horiz = this.horiz = elt(\"div\", [elt(\"div\", null, null, \"height: 100%; min-height: 1px\")], \"CodeMirror-hscrollbar\")\n  place(vert); place(horiz)\n\n  on(vert, \"scroll\", function () {\n    if (vert.clientHeight) { scroll(vert.scrollTop, \"vertical\") }\n  })\n  on(horiz, \"scroll\", function () {\n    if (horiz.clientWidth) { scroll(horiz.scrollLeft, \"horizontal\") }\n  })\n\n  this.checkedZeroWidth = false\n  // Need to set a minimum width to see the scrollbar on IE7 (but must not set it on IE8).\n  if (ie && ie_version < 8) { this.horiz.style.minHeight = this.vert.style.minWidth = \"18px\" }\n};\n\nNativeScrollbars.prototype.update = function (measure) {\n  var needsH = measure.scrollWidth > measure.clientWidth + 1\n  var needsV = measure.scrollHeight > measure.clientHeight + 1\n  var sWidth = measure.nativeBarWidth\n\n  if (needsV) {\n    this.vert.style.display = \"block\"\n    this.vert.style.bottom = needsH ? sWidth + \"px\" : \"0\"\n    var totalHeight = measure.viewHeight - (needsH ? sWidth : 0)\n    // A bug in IE8 can cause this value to be negative, so guard it.\n    this.vert.firstChild.style.height =\n      Math.max(0, measure.scrollHeight - measure.clientHeight + totalHeight) + \"px\"\n  } else {\n    this.vert.style.display = \"\"\n    this.vert.firstChild.style.height = \"0\"\n  }\n\n  if (needsH) {\n    this.horiz.style.display = \"block\"\n    this.horiz.style.right = needsV ? sWidth + \"px\" : \"0\"\n    this.horiz.style.left = measure.barLeft + \"px\"\n    var totalWidth = measure.viewWidth - measure.barLeft - (needsV ? sWidth : 0)\n    this.horiz.firstChild.style.width =\n      Math.max(0, measure.scrollWidth - measure.clientWidth + totalWidth) + \"px\"\n  } else {\n    this.horiz.style.display = \"\"\n    this.horiz.firstChild.style.width = \"0\"\n  }\n\n  if (!this.checkedZeroWidth && measure.clientHeight > 0) {\n    if (sWidth == 0) { this.zeroWidthHack() }\n    this.checkedZeroWidth = true\n  }\n\n  return {right: needsV ? sWidth : 0, bottom: needsH ? sWidth : 0}\n};\n\nNativeScrollbars.prototype.setScrollLeft = function (pos) {\n  if (this.horiz.scrollLeft != pos) { this.horiz.scrollLeft = pos }\n  if (this.disableHoriz) { this.enableZeroWidthBar(this.horiz, this.disableHoriz) }\n};\n\nNativeScrollbars.prototype.setScrollTop = function (pos) {\n  if (this.vert.scrollTop != pos) { this.vert.scrollTop = pos }\n  if (this.disableVert) { this.enableZeroWidthBar(this.vert, this.disableVert) }\n};\n\nNativeScrollbars.prototype.zeroWidthHack = function () {\n  var w = mac && !mac_geMountainLion ? \"12px\" : \"18px\"\n  this.horiz.style.height = this.vert.style.width = w\n  this.horiz.style.pointerEvents = this.vert.style.pointerEvents = \"none\"\n  this.disableHoriz = new Delayed\n  this.disableVert = new Delayed\n};\n\nNativeScrollbars.prototype.enableZeroWidthBar = function (bar, delay) {\n  bar.style.pointerEvents = \"auto\"\n  function maybeDisable() {\n    // To find out whether the scrollbar is still visible, we\n    // check whether the element under the pixel in the bottom\n    // left corner of the scrollbar box is the scrollbar box\n    // itself (when the bar is still visible) or its filler child\n    // (when the bar is hidden). If it is still visible, we keep\n    // it enabled, if it's hidden, we disable pointer events.\n    var box = bar.getBoundingClientRect()\n    var elt = document.elementFromPoint(box.left + 1, box.bottom - 1)\n    if (elt != bar) { bar.style.pointerEvents = \"none\" }\n    else { delay.set(1000, maybeDisable) }\n  }\n  delay.set(1000, maybeDisable)\n};\n\nNativeScrollbars.prototype.clear = function () {\n  var parent = this.horiz.parentNode\n  parent.removeChild(this.horiz)\n  parent.removeChild(this.vert)\n};\n\nvar NullScrollbars = function () {};\n\nNullScrollbars.prototype.update = function () { return {bottom: 0, right: 0} };\nNullScrollbars.prototype.setScrollLeft = function () {};\nNullScrollbars.prototype.setScrollTop = function () {};\nNullScrollbars.prototype.clear = function () {};\n\nfunction updateScrollbars(cm, measure) {\n  if (!measure) { measure = measureForScrollbars(cm) }\n  var startWidth = cm.display.barWidth, startHeight = cm.display.barHeight\n  updateScrollbarsInner(cm, measure)\n  for (var i = 0; i < 4 && startWidth != cm.display.barWidth || startHeight != cm.display.barHeight; i++) {\n    if (startWidth != cm.display.barWidth && cm.options.lineWrapping)\n      { updateHeightsInViewport(cm) }\n    updateScrollbarsInner(cm, measureForScrollbars(cm))\n    startWidth = cm.display.barWidth; startHeight = cm.display.barHeight\n  }\n}\n\n// Re-synchronize the fake scrollbars with the actual size of the\n// content.\nfunction updateScrollbarsInner(cm, measure) {\n  var d = cm.display\n  var sizes = d.scrollbars.update(measure)\n\n  d.sizer.style.paddingRight = (d.barWidth = sizes.right) + \"px\"\n  d.sizer.style.paddingBottom = (d.barHeight = sizes.bottom) + \"px\"\n  d.heightForcer.style.borderBottom = sizes.bottom + \"px solid transparent\"\n\n  if (sizes.right && sizes.bottom) {\n    d.scrollbarFiller.style.display = \"block\"\n    d.scrollbarFiller.style.height = sizes.bottom + \"px\"\n    d.scrollbarFiller.style.width = sizes.right + \"px\"\n  } else { d.scrollbarFiller.style.display = \"\" }\n  if (sizes.bottom && cm.options.coverGutterNextToScrollbar && cm.options.fixedGutter) {\n    d.gutterFiller.style.display = \"block\"\n    d.gutterFiller.style.height = sizes.bottom + \"px\"\n    d.gutterFiller.style.width = measure.gutterWidth + \"px\"\n  } else { d.gutterFiller.style.display = \"\" }\n}\n\nvar scrollbarModel = {\"native\": NativeScrollbars, \"null\": NullScrollbars}\n\nfunction initScrollbars(cm) {\n  if (cm.display.scrollbars) {\n    cm.display.scrollbars.clear()\n    if (cm.display.scrollbars.addClass)\n      { rmClass(cm.display.wrapper, cm.display.scrollbars.addClass) }\n  }\n\n  cm.display.scrollbars = new scrollbarModel[cm.options.scrollbarStyle](function (node) {\n    cm.display.wrapper.insertBefore(node, cm.display.scrollbarFiller)\n    // Prevent clicks in the scrollbars from killing focus\n    on(node, \"mousedown\", function () {\n      if (cm.state.focused) { setTimeout(function () { return cm.display.input.focus(); }, 0) }\n    })\n    node.setAttribute(\"cm-not-content\", \"true\")\n  }, function (pos, axis) {\n    if (axis == \"horizontal\") { setScrollLeft(cm, pos) }\n    else { setScrollTop(cm, pos) }\n  }, cm)\n  if (cm.display.scrollbars.addClass)\n    { addClass(cm.display.wrapper, cm.display.scrollbars.addClass) }\n}\n\n// SCROLLING THINGS INTO VIEW\n\n// If an editor sits on the top or bottom of the window, partially\n// scrolled out of view, this ensures that the cursor is visible.\nfunction maybeScrollWindow(cm, coords) {\n  if (signalDOMEvent(cm, \"scrollCursorIntoView\")) { return }\n\n  var display = cm.display, box = display.sizer.getBoundingClientRect(), doScroll = null\n  if (coords.top + box.top < 0) { doScroll = true }\n  else if (coords.bottom + box.top > (window.innerHeight || document.documentElement.clientHeight)) { doScroll = false }\n  if (doScroll != null && !phantom) {\n    var scrollNode = elt(\"div\", \"\\u200b\", null, (\"position: absolute;\\n                         top: \" + (coords.top - display.viewOffset - paddingTop(cm.display)) + \"px;\\n                         height: \" + (coords.bottom - coords.top + scrollGap(cm) + display.barHeight) + \"px;\\n                         left: \" + (coords.left) + \"px; width: 2px;\"))\n    cm.display.lineSpace.appendChild(scrollNode)\n    scrollNode.scrollIntoView(doScroll)\n    cm.display.lineSpace.removeChild(scrollNode)\n  }\n}\n\n// Scroll a given position into view (immediately), verifying that\n// it actually became visible (as line heights are accurately\n// measured, the position of something may 'drift' during drawing).\nfunction scrollPosIntoView(cm, pos, end, margin) {\n  if (margin == null) { margin = 0 }\n  var coords\n  for (var limit = 0; limit < 5; limit++) {\n    var changed = false\n    coords = cursorCoords(cm, pos)\n    var endCoords = !end || end == pos ? coords : cursorCoords(cm, end)\n    var scrollPos = calculateScrollPos(cm, Math.min(coords.left, endCoords.left),\n                                       Math.min(coords.top, endCoords.top) - margin,\n                                       Math.max(coords.left, endCoords.left),\n                                       Math.max(coords.bottom, endCoords.bottom) + margin)\n    var startTop = cm.doc.scrollTop, startLeft = cm.doc.scrollLeft\n    if (scrollPos.scrollTop != null) {\n      setScrollTop(cm, scrollPos.scrollTop)\n      if (Math.abs(cm.doc.scrollTop - startTop) > 1) { changed = true }\n    }\n    if (scrollPos.scrollLeft != null) {\n      setScrollLeft(cm, scrollPos.scrollLeft)\n      if (Math.abs(cm.doc.scrollLeft - startLeft) > 1) { changed = true }\n    }\n    if (!changed) { break }\n  }\n  return coords\n}\n\n// Scroll a given set of coordinates into view (immediately).\nfunction scrollIntoView(cm, x1, y1, x2, y2) {\n  var scrollPos = calculateScrollPos(cm, x1, y1, x2, y2)\n  if (scrollPos.scrollTop != null) { setScrollTop(cm, scrollPos.scrollTop) }\n  if (scrollPos.scrollLeft != null) { setScrollLeft(cm, scrollPos.scrollLeft) }\n}\n\n// Calculate a new scroll position needed to scroll the given\n// rectangle into view. Returns an object with scrollTop and\n// scrollLeft properties. When these are undefined, the\n// vertical/horizontal position does not need to be adjusted.\nfunction calculateScrollPos(cm, x1, y1, x2, y2) {\n  var display = cm.display, snapMargin = textHeight(cm.display)\n  if (y1 < 0) { y1 = 0 }\n  var screentop = cm.curOp && cm.curOp.scrollTop != null ? cm.curOp.scrollTop : display.scroller.scrollTop\n  var screen = displayHeight(cm), result = {}\n  if (y2 - y1 > screen) { y2 = y1 + screen }\n  var docBottom = cm.doc.height + paddingVert(display)\n  var atTop = y1 < snapMargin, atBottom = y2 > docBottom - snapMargin\n  if (y1 < screentop) {\n    result.scrollTop = atTop ? 0 : y1\n  } else if (y2 > screentop + screen) {\n    var newTop = Math.min(y1, (atBottom ? docBottom : y2) - screen)\n    if (newTop != screentop) { result.scrollTop = newTop }\n  }\n\n  var screenleft = cm.curOp && cm.curOp.scrollLeft != null ? cm.curOp.scrollLeft : display.scroller.scrollLeft\n  var screenw = displayWidth(cm) - (cm.options.fixedGutter ? display.gutters.offsetWidth : 0)\n  var tooWide = x2 - x1 > screenw\n  if (tooWide) { x2 = x1 + screenw }\n  if (x1 < 10)\n    { result.scrollLeft = 0 }\n  else if (x1 < screenleft)\n    { result.scrollLeft = Math.max(0, x1 - (tooWide ? 0 : 10)) }\n  else if (x2 > screenw + screenleft - 3)\n    { result.scrollLeft = x2 + (tooWide ? 0 : 10) - screenw }\n  return result\n}\n\n// Store a relative adjustment to the scroll position in the current\n// operation (to be applied when the operation finishes).\nfunction addToScrollPos(cm, left, top) {\n  if (left != null || top != null) { resolveScrollToPos(cm) }\n  if (left != null)\n    { cm.curOp.scrollLeft = (cm.curOp.scrollLeft == null ? cm.doc.scrollLeft : cm.curOp.scrollLeft) + left }\n  if (top != null)\n    { cm.curOp.scrollTop = (cm.curOp.scrollTop == null ? cm.doc.scrollTop : cm.curOp.scrollTop) + top }\n}\n\n// Make sure that at the end of the operation the current cursor is\n// shown.\nfunction ensureCursorVisible(cm) {\n  resolveScrollToPos(cm)\n  var cur = cm.getCursor(), from = cur, to = cur\n  if (!cm.options.lineWrapping) {\n    from = cur.ch ? Pos(cur.line, cur.ch - 1) : cur\n    to = Pos(cur.line, cur.ch + 1)\n  }\n  cm.curOp.scrollToPos = {from: from, to: to, margin: cm.options.cursorScrollMargin, isCursor: true}\n}\n\n// When an operation has its scrollToPos property set, and another\n// scroll action is applied before the end of the operation, this\n// 'simulates' scrolling that position into view in a cheap way, so\n// that the effect of intermediate scroll commands is not ignored.\nfunction resolveScrollToPos(cm) {\n  var range = cm.curOp.scrollToPos\n  if (range) {\n    cm.curOp.scrollToPos = null\n    var from = estimateCoords(cm, range.from), to = estimateCoords(cm, range.to)\n    var sPos = calculateScrollPos(cm, Math.min(from.left, to.left),\n                                  Math.min(from.top, to.top) - range.margin,\n                                  Math.max(from.right, to.right),\n                                  Math.max(from.bottom, to.bottom) + range.margin)\n    cm.scrollTo(sPos.scrollLeft, sPos.scrollTop)\n  }\n}\n\n// Operations are used to wrap a series of changes to the editor\n// state in such a way that each change won't have to update the\n// cursor and display (which would be awkward, slow, and\n// error-prone). Instead, display updates are batched and then all\n// combined and executed at once.\n\nvar nextOpId = 0\n// Start a new operation.\nfunction startOperation(cm) {\n  cm.curOp = {\n    cm: cm,\n    viewChanged: false,      // Flag that indicates that lines might need to be redrawn\n    startHeight: cm.doc.height, // Used to detect need to update scrollbar\n    forceUpdate: false,      // Used to force a redraw\n    updateInput: null,       // Whether to reset the input textarea\n    typing: false,           // Whether this reset should be careful to leave existing text (for compositing)\n    changeObjs: null,        // Accumulated changes, for firing change events\n    cursorActivityHandlers: null, // Set of handlers to fire cursorActivity on\n    cursorActivityCalled: 0, // Tracks which cursorActivity handlers have been called already\n    selectionChanged: false, // Whether the selection needs to be redrawn\n    updateMaxLine: false,    // Set when the widest line needs to be determined anew\n    scrollLeft: null, scrollTop: null, // Intermediate scroll position, not pushed to DOM yet\n    scrollToPos: null,       // Used to scroll to a specific position\n    focus: false,\n    id: ++nextOpId           // Unique ID\n  }\n  pushOperation(cm.curOp)\n}\n\n// Finish an operation, updating the display and signalling delayed events\nfunction endOperation(cm) {\n  var op = cm.curOp\n  finishOperation(op, function (group) {\n    for (var i = 0; i < group.ops.length; i++)\n      { group.ops[i].cm.curOp = null }\n    endOperations(group)\n  })\n}\n\n// The DOM updates done when an operation finishes are batched so\n// that the minimum number of relayouts are required.\nfunction endOperations(group) {\n  var ops = group.ops\n  for (var i = 0; i < ops.length; i++) // Read DOM\n    { endOperation_R1(ops[i]) }\n  for (var i$1 = 0; i$1 < ops.length; i$1++) // Write DOM (maybe)\n    { endOperation_W1(ops[i$1]) }\n  for (var i$2 = 0; i$2 < ops.length; i$2++) // Read DOM\n    { endOperation_R2(ops[i$2]) }\n  for (var i$3 = 0; i$3 < ops.length; i$3++) // Write DOM (maybe)\n    { endOperation_W2(ops[i$3]) }\n  for (var i$4 = 0; i$4 < ops.length; i$4++) // Read DOM\n    { endOperation_finish(ops[i$4]) }\n}\n\nfunction endOperation_R1(op) {\n  var cm = op.cm, display = cm.display\n  maybeClipScrollbars(cm)\n  if (op.updateMaxLine) { findMaxLine(cm) }\n\n  op.mustUpdate = op.viewChanged || op.forceUpdate || op.scrollTop != null ||\n    op.scrollToPos && (op.scrollToPos.from.line < display.viewFrom ||\n                       op.scrollToPos.to.line >= display.viewTo) ||\n    display.maxLineChanged && cm.options.lineWrapping\n  op.update = op.mustUpdate &&\n    new DisplayUpdate(cm, op.mustUpdate && {top: op.scrollTop, ensure: op.scrollToPos}, op.forceUpdate)\n}\n\nfunction endOperation_W1(op) {\n  op.updatedDisplay = op.mustUpdate && updateDisplayIfNeeded(op.cm, op.update)\n}\n\nfunction endOperation_R2(op) {\n  var cm = op.cm, display = cm.display\n  if (op.updatedDisplay) { updateHeightsInViewport(cm) }\n\n  op.barMeasure = measureForScrollbars(cm)\n\n  // If the max line changed since it was last measured, measure it,\n  // and ensure the document's width matches it.\n  // updateDisplay_W2 will use these properties to do the actual resizing\n  if (display.maxLineChanged && !cm.options.lineWrapping) {\n    op.adjustWidthTo = measureChar(cm, display.maxLine, display.maxLine.text.length).left + 3\n    cm.display.sizerWidth = op.adjustWidthTo\n    op.barMeasure.scrollWidth =\n      Math.max(display.scroller.clientWidth, display.sizer.offsetLeft + op.adjustWidthTo + scrollGap(cm) + cm.display.barWidth)\n    op.maxScrollLeft = Math.max(0, display.sizer.offsetLeft + op.adjustWidthTo - displayWidth(cm))\n  }\n\n  if (op.updatedDisplay || op.selectionChanged)\n    { op.preparedSelection = display.input.prepareSelection(op.focus) }\n}\n\nfunction endOperation_W2(op) {\n  var cm = op.cm\n\n  if (op.adjustWidthTo != null) {\n    cm.display.sizer.style.minWidth = op.adjustWidthTo + \"px\"\n    if (op.maxScrollLeft < cm.doc.scrollLeft)\n      { setScrollLeft(cm, Math.min(cm.display.scroller.scrollLeft, op.maxScrollLeft), true) }\n    cm.display.maxLineChanged = false\n  }\n\n  var takeFocus = op.focus && op.focus == activeElt() && (!document.hasFocus || document.hasFocus())\n  if (op.preparedSelection)\n    { cm.display.input.showSelection(op.preparedSelection, takeFocus) }\n  if (op.updatedDisplay || op.startHeight != cm.doc.height)\n    { updateScrollbars(cm, op.barMeasure) }\n  if (op.updatedDisplay)\n    { setDocumentHeight(cm, op.barMeasure) }\n\n  if (op.selectionChanged) { restartBlink(cm) }\n\n  if (cm.state.focused && op.updateInput)\n    { cm.display.input.reset(op.typing) }\n  if (takeFocus) { ensureFocus(op.cm) }\n}\n\nfunction endOperation_finish(op) {\n  var cm = op.cm, display = cm.display, doc = cm.doc\n\n  if (op.updatedDisplay) { postUpdateDisplay(cm, op.update) }\n\n  // Abort mouse wheel delta measurement, when scrolling explicitly\n  if (display.wheelStartX != null && (op.scrollTop != null || op.scrollLeft != null || op.scrollToPos))\n    { display.wheelStartX = display.wheelStartY = null }\n\n  // Propagate the scroll position to the actual DOM scroller\n  if (op.scrollTop != null && (display.scroller.scrollTop != op.scrollTop || op.forceScroll)) {\n    doc.scrollTop = Math.max(0, Math.min(display.scroller.scrollHeight - display.scroller.clientHeight, op.scrollTop))\n    display.scrollbars.setScrollTop(doc.scrollTop)\n    display.scroller.scrollTop = doc.scrollTop\n  }\n  if (op.scrollLeft != null && (display.scroller.scrollLeft != op.scrollLeft || op.forceScroll)) {\n    doc.scrollLeft = Math.max(0, Math.min(display.scroller.scrollWidth - display.scroller.clientWidth, op.scrollLeft))\n    display.scrollbars.setScrollLeft(doc.scrollLeft)\n    display.scroller.scrollLeft = doc.scrollLeft\n    alignHorizontally(cm)\n  }\n  // If we need to scroll a specific position into view, do so.\n  if (op.scrollToPos) {\n    var coords = scrollPosIntoView(cm, clipPos(doc, op.scrollToPos.from),\n                                   clipPos(doc, op.scrollToPos.to), op.scrollToPos.margin)\n    if (op.scrollToPos.isCursor && cm.state.focused) { maybeScrollWindow(cm, coords) }\n  }\n\n  // Fire events for markers that are hidden/unidden by editing or\n  // undoing\n  var hidden = op.maybeHiddenMarkers, unhidden = op.maybeUnhiddenMarkers\n  if (hidden) { for (var i = 0; i < hidden.length; ++i)\n    { if (!hidden[i].lines.length) { signal(hidden[i], \"hide\") } } }\n  if (unhidden) { for (var i$1 = 0; i$1 < unhidden.length; ++i$1)\n    { if (unhidden[i$1].lines.length) { signal(unhidden[i$1], \"unhide\") } } }\n\n  if (display.wrapper.offsetHeight)\n    { doc.scrollTop = cm.display.scroller.scrollTop }\n\n  // Fire change events, and delayed event handlers\n  if (op.changeObjs)\n    { signal(cm, \"changes\", cm, op.changeObjs) }\n  if (op.update)\n    { op.update.finish() }\n}\n\n// Run the given function in an operation\nfunction runInOp(cm, f) {\n  if (cm.curOp) { return f() }\n  startOperation(cm)\n  try { return f() }\n  finally { endOperation(cm) }\n}\n// Wraps a function in an operation. Returns the wrapped function.\nfunction operation(cm, f) {\n  return function() {\n    if (cm.curOp) { return f.apply(cm, arguments) }\n    startOperation(cm)\n    try { return f.apply(cm, arguments) }\n    finally { endOperation(cm) }\n  }\n}\n// Used to add methods to editor and doc instances, wrapping them in\n// operations.\nfunction methodOp(f) {\n  return function() {\n    if (this.curOp) { return f.apply(this, arguments) }\n    startOperation(this)\n    try { return f.apply(this, arguments) }\n    finally { endOperation(this) }\n  }\n}\nfunction docMethodOp(f) {\n  return function() {\n    var cm = this.cm\n    if (!cm || cm.curOp) { return f.apply(this, arguments) }\n    startOperation(cm)\n    try { return f.apply(this, arguments) }\n    finally { endOperation(cm) }\n  }\n}\n\n// Updates the display.view data structure for a given change to the\n// document. From and to are in pre-change coordinates. Lendiff is\n// the amount of lines added or subtracted by the change. This is\n// used for changes that span multiple lines, or change the way\n// lines are divided into visual lines. regLineChange (below)\n// registers single-line changes.\nfunction regChange(cm, from, to, lendiff) {\n  if (from == null) { from = cm.doc.first }\n  if (to == null) { to = cm.doc.first + cm.doc.size }\n  if (!lendiff) { lendiff = 0 }\n\n  var display = cm.display\n  if (lendiff && to < display.viewTo &&\n      (display.updateLineNumbers == null || display.updateLineNumbers > from))\n    { display.updateLineNumbers = from }\n\n  cm.curOp.viewChanged = true\n\n  if (from >= display.viewTo) { // Change after\n    if (sawCollapsedSpans && visualLineNo(cm.doc, from) < display.viewTo)\n      { resetView(cm) }\n  } else if (to <= display.viewFrom) { // Change before\n    if (sawCollapsedSpans && visualLineEndNo(cm.doc, to + lendiff) > display.viewFrom) {\n      resetView(cm)\n    } else {\n      display.viewFrom += lendiff\n      display.viewTo += lendiff\n    }\n  } else if (from <= display.viewFrom && to >= display.viewTo) { // Full overlap\n    resetView(cm)\n  } else if (from <= display.viewFrom) { // Top overlap\n    var cut = viewCuttingPoint(cm, to, to + lendiff, 1)\n    if (cut) {\n      display.view = display.view.slice(cut.index)\n      display.viewFrom = cut.lineN\n      display.viewTo += lendiff\n    } else {\n      resetView(cm)\n    }\n  } else if (to >= display.viewTo) { // Bottom overlap\n    var cut$1 = viewCuttingPoint(cm, from, from, -1)\n    if (cut$1) {\n      display.view = display.view.slice(0, cut$1.index)\n      display.viewTo = cut$1.lineN\n    } else {\n      resetView(cm)\n    }\n  } else { // Gap in the middle\n    var cutTop = viewCuttingPoint(cm, from, from, -1)\n    var cutBot = viewCuttingPoint(cm, to, to + lendiff, 1)\n    if (cutTop && cutBot) {\n      display.view = display.view.slice(0, cutTop.index)\n        .concat(buildViewArray(cm, cutTop.lineN, cutBot.lineN))\n        .concat(display.view.slice(cutBot.index))\n      display.viewTo += lendiff\n    } else {\n      resetView(cm)\n    }\n  }\n\n  var ext = display.externalMeasured\n  if (ext) {\n    if (to < ext.lineN)\n      { ext.lineN += lendiff }\n    else if (from < ext.lineN + ext.size)\n      { display.externalMeasured = null }\n  }\n}\n\n// Register a change to a single line. Type must be one of \"text\",\n// \"gutter\", \"class\", \"widget\"\nfunction regLineChange(cm, line, type) {\n  cm.curOp.viewChanged = true\n  var display = cm.display, ext = cm.display.externalMeasured\n  if (ext && line >= ext.lineN && line < ext.lineN + ext.size)\n    { display.externalMeasured = null }\n\n  if (line < display.viewFrom || line >= display.viewTo) { return }\n  var lineView = display.view[findViewIndex(cm, line)]\n  if (lineView.node == null) { return }\n  var arr = lineView.changes || (lineView.changes = [])\n  if (indexOf(arr, type) == -1) { arr.push(type) }\n}\n\n// Clear the view.\nfunction resetView(cm) {\n  cm.display.viewFrom = cm.display.viewTo = cm.doc.first\n  cm.display.view = []\n  cm.display.viewOffset = 0\n}\n\nfunction viewCuttingPoint(cm, oldN, newN, dir) {\n  var index = findViewIndex(cm, oldN), diff, view = cm.display.view\n  if (!sawCollapsedSpans || newN == cm.doc.first + cm.doc.size)\n    { return {index: index, lineN: newN} }\n  var n = cm.display.viewFrom\n  for (var i = 0; i < index; i++)\n    { n += view[i].size }\n  if (n != oldN) {\n    if (dir > 0) {\n      if (index == view.length - 1) { return null }\n      diff = (n + view[index].size) - oldN\n      index++\n    } else {\n      diff = n - oldN\n    }\n    oldN += diff; newN += diff\n  }\n  while (visualLineNo(cm.doc, newN) != newN) {\n    if (index == (dir < 0 ? 0 : view.length - 1)) { return null }\n    newN += dir * view[index - (dir < 0 ? 1 : 0)].size\n    index += dir\n  }\n  return {index: index, lineN: newN}\n}\n\n// Force the view to cover a given range, adding empty view element\n// or clipping off existing ones as needed.\nfunction adjustView(cm, from, to) {\n  var display = cm.display, view = display.view\n  if (view.length == 0 || from >= display.viewTo || to <= display.viewFrom) {\n    display.view = buildViewArray(cm, from, to)\n    display.viewFrom = from\n  } else {\n    if (display.viewFrom > from)\n      { display.view = buildViewArray(cm, from, display.viewFrom).concat(display.view) }\n    else if (display.viewFrom < from)\n      { display.view = display.view.slice(findViewIndex(cm, from)) }\n    display.viewFrom = from\n    if (display.viewTo < to)\n      { display.view = display.view.concat(buildViewArray(cm, display.viewTo, to)) }\n    else if (display.viewTo > to)\n      { display.view = display.view.slice(0, findViewIndex(cm, to)) }\n  }\n  display.viewTo = to\n}\n\n// Count the number of lines in the view whose DOM representation is\n// out of date (or nonexistent).\nfunction countDirtyView(cm) {\n  var view = cm.display.view, dirty = 0\n  for (var i = 0; i < view.length; i++) {\n    var lineView = view[i]\n    if (!lineView.hidden && (!lineView.node || lineView.changes)) { ++dirty }\n  }\n  return dirty\n}\n\n// HIGHLIGHT WORKER\n\nfunction startWorker(cm, time) {\n  if (cm.doc.mode.startState && cm.doc.frontier < cm.display.viewTo)\n    { cm.state.highlight.set(time, bind(highlightWorker, cm)) }\n}\n\nfunction highlightWorker(cm) {\n  var doc = cm.doc\n  if (doc.frontier < doc.first) { doc.frontier = doc.first }\n  if (doc.frontier >= cm.display.viewTo) { return }\n  var end = +new Date + cm.options.workTime\n  var state = copyState(doc.mode, getStateBefore(cm, doc.frontier))\n  var changedLines = []\n\n  doc.iter(doc.frontier, Math.min(doc.first + doc.size, cm.display.viewTo + 500), function (line) {\n    if (doc.frontier >= cm.display.viewFrom) { // Visible\n      var oldStyles = line.styles, tooLong = line.text.length > cm.options.maxHighlightLength\n      var highlighted = highlightLine(cm, line, tooLong ? copyState(doc.mode, state) : state, true)\n      line.styles = highlighted.styles\n      var oldCls = line.styleClasses, newCls = highlighted.classes\n      if (newCls) { line.styleClasses = newCls }\n      else if (oldCls) { line.styleClasses = null }\n      var ischange = !oldStyles || oldStyles.length != line.styles.length ||\n        oldCls != newCls && (!oldCls || !newCls || oldCls.bgClass != newCls.bgClass || oldCls.textClass != newCls.textClass)\n      for (var i = 0; !ischange && i < oldStyles.length; ++i) { ischange = oldStyles[i] != line.styles[i] }\n      if (ischange) { changedLines.push(doc.frontier) }\n      line.stateAfter = tooLong ? state : copyState(doc.mode, state)\n    } else {\n      if (line.text.length <= cm.options.maxHighlightLength)\n        { processLine(cm, line.text, state) }\n      line.stateAfter = doc.frontier % 5 == 0 ? copyState(doc.mode, state) : null\n    }\n    ++doc.frontier\n    if (+new Date > end) {\n      startWorker(cm, cm.options.workDelay)\n      return true\n    }\n  })\n  if (changedLines.length) { runInOp(cm, function () {\n    for (var i = 0; i < changedLines.length; i++)\n      { regLineChange(cm, changedLines[i], \"text\") }\n  }) }\n}\n\n// DISPLAY DRAWING\n\nvar DisplayUpdate = function(cm, viewport, force) {\n  var display = cm.display\n\n  this.viewport = viewport\n  // Store some values that we'll need later (but don't want to force a relayout for)\n  this.visible = visibleLines(display, cm.doc, viewport)\n  this.editorIsHidden = !display.wrapper.offsetWidth\n  this.wrapperHeight = display.wrapper.clientHeight\n  this.wrapperWidth = display.wrapper.clientWidth\n  this.oldDisplayWidth = displayWidth(cm)\n  this.force = force\n  this.dims = getDimensions(cm)\n  this.events = []\n};\n\nDisplayUpdate.prototype.signal = function (emitter, type) {\n  if (hasHandler(emitter, type))\n    { this.events.push(arguments) }\n};\nDisplayUpdate.prototype.finish = function () {\n    var this$1 = this;\n\n  for (var i = 0; i < this.events.length; i++)\n    { signal.apply(null, this$1.events[i]) }\n};\n\nfunction maybeClipScrollbars(cm) {\n  var display = cm.display\n  if (!display.scrollbarsClipped && display.scroller.offsetWidth) {\n    display.nativeBarWidth = display.scroller.offsetWidth - display.scroller.clientWidth\n    display.heightForcer.style.height = scrollGap(cm) + \"px\"\n    display.sizer.style.marginBottom = -display.nativeBarWidth + \"px\"\n    display.sizer.style.borderRightWidth = scrollGap(cm) + \"px\"\n    display.scrollbarsClipped = true\n  }\n}\n\n// Does the actual updating of the line display. Bails out\n// (returning false) when there is nothing to be done and forced is\n// false.\nfunction updateDisplayIfNeeded(cm, update) {\n  var display = cm.display, doc = cm.doc\n\n  if (update.editorIsHidden) {\n    resetView(cm)\n    return false\n  }\n\n  // Bail out if the visible area is already rendered and nothing changed.\n  if (!update.force &&\n      update.visible.from >= display.viewFrom && update.visible.to <= display.viewTo &&\n      (display.updateLineNumbers == null || display.updateLineNumbers >= display.viewTo) &&\n      display.renderedView == display.view && countDirtyView(cm) == 0)\n    { return false }\n\n  if (maybeUpdateLineNumberWidth(cm)) {\n    resetView(cm)\n    update.dims = getDimensions(cm)\n  }\n\n  // Compute a suitable new viewport (from & to)\n  var end = doc.first + doc.size\n  var from = Math.max(update.visible.from - cm.options.viewportMargin, doc.first)\n  var to = Math.min(end, update.visible.to + cm.options.viewportMargin)\n  if (display.viewFrom < from && from - display.viewFrom < 20) { from = Math.max(doc.first, display.viewFrom) }\n  if (display.viewTo > to && display.viewTo - to < 20) { to = Math.min(end, display.viewTo) }\n  if (sawCollapsedSpans) {\n    from = visualLineNo(cm.doc, from)\n    to = visualLineEndNo(cm.doc, to)\n  }\n\n  var different = from != display.viewFrom || to != display.viewTo ||\n    display.lastWrapHeight != update.wrapperHeight || display.lastWrapWidth != update.wrapperWidth\n  adjustView(cm, from, to)\n\n  display.viewOffset = heightAtLine(getLine(cm.doc, display.viewFrom))\n  // Position the mover div to align with the current scroll position\n  cm.display.mover.style.top = display.viewOffset + \"px\"\n\n  var toUpdate = countDirtyView(cm)\n  if (!different && toUpdate == 0 && !update.force && display.renderedView == display.view &&\n      (display.updateLineNumbers == null || display.updateLineNumbers >= display.viewTo))\n    { return false }\n\n  // For big changes, we hide the enclosing element during the\n  // update, since that speeds up the operations on most browsers.\n  var focused = activeElt()\n  if (toUpdate > 4) { display.lineDiv.style.display = \"none\" }\n  patchDisplay(cm, display.updateLineNumbers, update.dims)\n  if (toUpdate > 4) { display.lineDiv.style.display = \"\" }\n  display.renderedView = display.view\n  // There might have been a widget with a focused element that got\n  // hidden or updated, if so re-focus it.\n  if (focused && activeElt() != focused && focused.offsetHeight) { focused.focus() }\n\n  // Prevent selection and cursors from interfering with the scroll\n  // width and height.\n  removeChildren(display.cursorDiv)\n  removeChildren(display.selectionDiv)\n  display.gutters.style.height = display.sizer.style.minHeight = 0\n\n  if (different) {\n    display.lastWrapHeight = update.wrapperHeight\n    display.lastWrapWidth = update.wrapperWidth\n    startWorker(cm, 400)\n  }\n\n  display.updateLineNumbers = null\n\n  return true\n}\n\nfunction postUpdateDisplay(cm, update) {\n  var viewport = update.viewport\n\n  for (var first = true;; first = false) {\n    if (!first || !cm.options.lineWrapping || update.oldDisplayWidth == displayWidth(cm)) {\n      // Clip forced viewport to actual scrollable area.\n      if (viewport && viewport.top != null)\n        { viewport = {top: Math.min(cm.doc.height + paddingVert(cm.display) - displayHeight(cm), viewport.top)} }\n      // Updated line heights might result in the drawn area not\n      // actually covering the viewport. Keep looping until it does.\n      update.visible = visibleLines(cm.display, cm.doc, viewport)\n      if (update.visible.from >= cm.display.viewFrom && update.visible.to <= cm.display.viewTo)\n        { break }\n    }\n    if (!updateDisplayIfNeeded(cm, update)) { break }\n    updateHeightsInViewport(cm)\n    var barMeasure = measureForScrollbars(cm)\n    updateSelection(cm)\n    updateScrollbars(cm, barMeasure)\n    setDocumentHeight(cm, barMeasure)\n  }\n\n  update.signal(cm, \"update\", cm)\n  if (cm.display.viewFrom != cm.display.reportedViewFrom || cm.display.viewTo != cm.display.reportedViewTo) {\n    update.signal(cm, \"viewportChange\", cm, cm.display.viewFrom, cm.display.viewTo)\n    cm.display.reportedViewFrom = cm.display.viewFrom; cm.display.reportedViewTo = cm.display.viewTo\n  }\n}\n\nfunction updateDisplaySimple(cm, viewport) {\n  var update = new DisplayUpdate(cm, viewport)\n  if (updateDisplayIfNeeded(cm, update)) {\n    updateHeightsInViewport(cm)\n    postUpdateDisplay(cm, update)\n    var barMeasure = measureForScrollbars(cm)\n    updateSelection(cm)\n    updateScrollbars(cm, barMeasure)\n    setDocumentHeight(cm, barMeasure)\n    update.finish()\n  }\n}\n\n// Sync the actual display DOM structure with display.view, removing\n// nodes for lines that are no longer in view, and creating the ones\n// that are not there yet, and updating the ones that are out of\n// date.\nfunction patchDisplay(cm, updateNumbersFrom, dims) {\n  var display = cm.display, lineNumbers = cm.options.lineNumbers\n  var container = display.lineDiv, cur = container.firstChild\n\n  function rm(node) {\n    var next = node.nextSibling\n    // Works around a throw-scroll bug in OS X Webkit\n    if (webkit && mac && cm.display.currentWheelTarget == node)\n      { node.style.display = \"none\" }\n    else\n      { node.parentNode.removeChild(node) }\n    return next\n  }\n\n  var view = display.view, lineN = display.viewFrom\n  // Loop over the elements in the view, syncing cur (the DOM nodes\n  // in display.lineDiv) with the view as we go.\n  for (var i = 0; i < view.length; i++) {\n    var lineView = view[i]\n    if (lineView.hidden) {\n    } else if (!lineView.node || lineView.node.parentNode != container) { // Not drawn yet\n      var node = buildLineElement(cm, lineView, lineN, dims)\n      container.insertBefore(node, cur)\n    } else { // Already drawn\n      while (cur != lineView.node) { cur = rm(cur) }\n      var updateNumber = lineNumbers && updateNumbersFrom != null &&\n        updateNumbersFrom <= lineN && lineView.lineNumber\n      if (lineView.changes) {\n        if (indexOf(lineView.changes, \"gutter\") > -1) { updateNumber = false }\n        updateLineForChanges(cm, lineView, lineN, dims)\n      }\n      if (updateNumber) {\n        removeChildren(lineView.lineNumber)\n        lineView.lineNumber.appendChild(document.createTextNode(lineNumberFor(cm.options, lineN)))\n      }\n      cur = lineView.node.nextSibling\n    }\n    lineN += lineView.size\n  }\n  while (cur) { cur = rm(cur) }\n}\n\nfunction updateGutterSpace(cm) {\n  var width = cm.display.gutters.offsetWidth\n  cm.display.sizer.style.marginLeft = width + \"px\"\n}\n\nfunction setDocumentHeight(cm, measure) {\n  cm.display.sizer.style.minHeight = measure.docHeight + \"px\"\n  cm.display.heightForcer.style.top = measure.docHeight + \"px\"\n  cm.display.gutters.style.height = (measure.docHeight + cm.display.barHeight + scrollGap(cm)) + \"px\"\n}\n\n// Rebuild the gutter elements, ensure the margin to the left of the\n// code matches their width.\nfunction updateGutters(cm) {\n  var gutters = cm.display.gutters, specs = cm.options.gutters\n  removeChildren(gutters)\n  var i = 0\n  for (; i < specs.length; ++i) {\n    var gutterClass = specs[i]\n    var gElt = gutters.appendChild(elt(\"div\", null, \"CodeMirror-gutter \" + gutterClass))\n    if (gutterClass == \"CodeMirror-linenumbers\") {\n      cm.display.lineGutter = gElt\n      gElt.style.width = (cm.display.lineNumWidth || 1) + \"px\"\n    }\n  }\n  gutters.style.display = i ? \"\" : \"none\"\n  updateGutterSpace(cm)\n}\n\n// Make sure the gutters options contains the element\n// \"CodeMirror-linenumbers\" when the lineNumbers option is true.\nfunction setGuttersForLineNumbers(options) {\n  var found = indexOf(options.gutters, \"CodeMirror-linenumbers\")\n  if (found == -1 && options.lineNumbers) {\n    options.gutters = options.gutters.concat([\"CodeMirror-linenumbers\"])\n  } else if (found > -1 && !options.lineNumbers) {\n    options.gutters = options.gutters.slice(0)\n    options.gutters.splice(found, 1)\n  }\n}\n\n// Selection objects are immutable. A new one is created every time\n// the selection changes. A selection is one or more non-overlapping\n// (and non-touching) ranges, sorted, and an integer that indicates\n// which one is the primary selection (the one that's scrolled into\n// view, that getCursor returns, etc).\nvar Selection = function(ranges, primIndex) {\n  this.ranges = ranges\n  this.primIndex = primIndex\n};\n\nSelection.prototype.primary = function () { return this.ranges[this.primIndex] };\n\nSelection.prototype.equals = function (other) {\n    var this$1 = this;\n\n  if (other == this) { return true }\n  if (other.primIndex != this.primIndex || other.ranges.length != this.ranges.length) { return false }\n  for (var i = 0; i < this.ranges.length; i++) {\n    var here = this$1.ranges[i], there = other.ranges[i]\n    if (!equalCursorPos(here.anchor, there.anchor) || !equalCursorPos(here.head, there.head)) { return false }\n  }\n  return true\n};\n\nSelection.prototype.deepCopy = function () {\n    var this$1 = this;\n\n  var out = []\n  for (var i = 0; i < this.ranges.length; i++)\n    { out[i] = new Range(copyPos(this$1.ranges[i].anchor), copyPos(this$1.ranges[i].head)) }\n  return new Selection(out, this.primIndex)\n};\n\nSelection.prototype.somethingSelected = function () {\n    var this$1 = this;\n\n  for (var i = 0; i < this.ranges.length; i++)\n    { if (!this$1.ranges[i].empty()) { return true } }\n  return false\n};\n\nSelection.prototype.contains = function (pos, end) {\n    var this$1 = this;\n\n  if (!end) { end = pos }\n  for (var i = 0; i < this.ranges.length; i++) {\n    var range = this$1.ranges[i]\n    if (cmp(end, range.from()) >= 0 && cmp(pos, range.to()) <= 0)\n      { return i }\n  }\n  return -1\n};\n\nvar Range = function(anchor, head) {\n  this.anchor = anchor; this.head = head\n};\n\nRange.prototype.from = function () { return minPos(this.anchor, this.head) };\nRange.prototype.to = function () { return maxPos(this.anchor, this.head) };\nRange.prototype.empty = function () { return this.head.line == this.anchor.line && this.head.ch == this.anchor.ch };\n\n// Take an unsorted, potentially overlapping set of ranges, and\n// build a selection out of it. 'Consumes' ranges array (modifying\n// it).\nfunction normalizeSelection(ranges, primIndex) {\n  var prim = ranges[primIndex]\n  ranges.sort(function (a, b) { return cmp(a.from(), b.from()); })\n  primIndex = indexOf(ranges, prim)\n  for (var i = 1; i < ranges.length; i++) {\n    var cur = ranges[i], prev = ranges[i - 1]\n    if (cmp(prev.to(), cur.from()) >= 0) {\n      var from = minPos(prev.from(), cur.from()), to = maxPos(prev.to(), cur.to())\n      var inv = prev.empty() ? cur.from() == cur.head : prev.from() == prev.head\n      if (i <= primIndex) { --primIndex }\n      ranges.splice(--i, 2, new Range(inv ? to : from, inv ? from : to))\n    }\n  }\n  return new Selection(ranges, primIndex)\n}\n\nfunction simpleSelection(anchor, head) {\n  return new Selection([new Range(anchor, head || anchor)], 0)\n}\n\n// Compute the position of the end of a change (its 'to' property\n// refers to the pre-change end).\nfunction changeEnd(change) {\n  if (!change.text) { return change.to }\n  return Pos(change.from.line + change.text.length - 1,\n             lst(change.text).length + (change.text.length == 1 ? change.from.ch : 0))\n}\n\n// Adjust a position to refer to the post-change position of the\n// same text, or the end of the change if the change covers it.\nfunction adjustForChange(pos, change) {\n  if (cmp(pos, change.from) < 0) { return pos }\n  if (cmp(pos, change.to) <= 0) { return changeEnd(change) }\n\n  var line = pos.line + change.text.length - (change.to.line - change.from.line) - 1, ch = pos.ch\n  if (pos.line == change.to.line) { ch += changeEnd(change).ch - change.to.ch }\n  return Pos(line, ch)\n}\n\nfunction computeSelAfterChange(doc, change) {\n  var out = []\n  for (var i = 0; i < doc.sel.ranges.length; i++) {\n    var range = doc.sel.ranges[i]\n    out.push(new Range(adjustForChange(range.anchor, change),\n                       adjustForChange(range.head, change)))\n  }\n  return normalizeSelection(out, doc.sel.primIndex)\n}\n\nfunction offsetPos(pos, old, nw) {\n  if (pos.line == old.line)\n    { return Pos(nw.line, pos.ch - old.ch + nw.ch) }\n  else\n    { return Pos(nw.line + (pos.line - old.line), pos.ch) }\n}\n\n// Used by replaceSelections to allow moving the selection to the\n// start or around the replaced test. Hint may be \"start\" or \"around\".\nfunction computeReplacedSel(doc, changes, hint) {\n  var out = []\n  var oldPrev = Pos(doc.first, 0), newPrev = oldPrev\n  for (var i = 0; i < changes.length; i++) {\n    var change = changes[i]\n    var from = offsetPos(change.from, oldPrev, newPrev)\n    var to = offsetPos(changeEnd(change), oldPrev, newPrev)\n    oldPrev = change.to\n    newPrev = to\n    if (hint == \"around\") {\n      var range = doc.sel.ranges[i], inv = cmp(range.head, range.anchor) < 0\n      out[i] = new Range(inv ? to : from, inv ? from : to)\n    } else {\n      out[i] = new Range(from, from)\n    }\n  }\n  return new Selection(out, doc.sel.primIndex)\n}\n\n// Used to get the editor into a consistent state again when options change.\n\nfunction loadMode(cm) {\n  cm.doc.mode = getMode(cm.options, cm.doc.modeOption)\n  resetModeState(cm)\n}\n\nfunction resetModeState(cm) {\n  cm.doc.iter(function (line) {\n    if (line.stateAfter) { line.stateAfter = null }\n    if (line.styles) { line.styles = null }\n  })\n  cm.doc.frontier = cm.doc.first\n  startWorker(cm, 100)\n  cm.state.modeGen++\n  if (cm.curOp) { regChange(cm) }\n}\n\n// DOCUMENT DATA STRUCTURE\n\n// By default, updates that start and end at the beginning of a line\n// are treated specially, in order to make the association of line\n// widgets and marker elements with the text behave more intuitive.\nfunction isWholeLineUpdate(doc, change) {\n  return change.from.ch == 0 && change.to.ch == 0 && lst(change.text) == \"\" &&\n    (!doc.cm || doc.cm.options.wholeLineUpdateBefore)\n}\n\n// Perform a change on the document data structure.\nfunction updateDoc(doc, change, markedSpans, estimateHeight) {\n  function spansFor(n) {return markedSpans ? markedSpans[n] : null}\n  function update(line, text, spans) {\n    updateLine(line, text, spans, estimateHeight)\n    signalLater(line, \"change\", line, change)\n  }\n  function linesFor(start, end) {\n    var result = []\n    for (var i = start; i < end; ++i)\n      { result.push(new Line(text[i], spansFor(i), estimateHeight)) }\n    return result\n  }\n\n  var from = change.from, to = change.to, text = change.text\n  var firstLine = getLine(doc, from.line), lastLine = getLine(doc, to.line)\n  var lastText = lst(text), lastSpans = spansFor(text.length - 1), nlines = to.line - from.line\n\n  // Adjust the line structure\n  if (change.full) {\n    doc.insert(0, linesFor(0, text.length))\n    doc.remove(text.length, doc.size - text.length)\n  } else if (isWholeLineUpdate(doc, change)) {\n    // This is a whole-line replace. Treated specially to make\n    // sure line objects move the way they are supposed to.\n    var added = linesFor(0, text.length - 1)\n    update(lastLine, lastLine.text, lastSpans)\n    if (nlines) { doc.remove(from.line, nlines) }\n    if (added.length) { doc.insert(from.line, added) }\n  } else if (firstLine == lastLine) {\n    if (text.length == 1) {\n      update(firstLine, firstLine.text.slice(0, from.ch) + lastText + firstLine.text.slice(to.ch), lastSpans)\n    } else {\n      var added$1 = linesFor(1, text.length - 1)\n      added$1.push(new Line(lastText + firstLine.text.slice(to.ch), lastSpans, estimateHeight))\n      update(firstLine, firstLine.text.slice(0, from.ch) + text[0], spansFor(0))\n      doc.insert(from.line + 1, added$1)\n    }\n  } else if (text.length == 1) {\n    update(firstLine, firstLine.text.slice(0, from.ch) + text[0] + lastLine.text.slice(to.ch), spansFor(0))\n    doc.remove(from.line + 1, nlines)\n  } else {\n    update(firstLine, firstLine.text.slice(0, from.ch) + text[0], spansFor(0))\n    update(lastLine, lastText + lastLine.text.slice(to.ch), lastSpans)\n    var added$2 = linesFor(1, text.length - 1)\n    if (nlines > 1) { doc.remove(from.line + 1, nlines - 1) }\n    doc.insert(from.line + 1, added$2)\n  }\n\n  signalLater(doc, \"change\", doc, change)\n}\n\n// Call f for all linked documents.\nfunction linkedDocs(doc, f, sharedHistOnly) {\n  function propagate(doc, skip, sharedHist) {\n    if (doc.linked) { for (var i = 0; i < doc.linked.length; ++i) {\n      var rel = doc.linked[i]\n      if (rel.doc == skip) { continue }\n      var shared = sharedHist && rel.sharedHist\n      if (sharedHistOnly && !shared) { continue }\n      f(rel.doc, shared)\n      propagate(rel.doc, doc, shared)\n    } }\n  }\n  propagate(doc, null, true)\n}\n\n// Attach a document to an editor.\nfunction attachDoc(cm, doc) {\n  if (doc.cm) { throw new Error(\"This document is already in use.\") }\n  cm.doc = doc\n  doc.cm = cm\n  estimateLineHeights(cm)\n  loadMode(cm)\n  if (!cm.options.lineWrapping) { findMaxLine(cm) }\n  cm.options.mode = doc.modeOption\n  regChange(cm)\n}\n\nfunction History(startGen) {\n  // Arrays of change events and selections. Doing something adds an\n  // event to done and clears undo. Undoing moves events from done\n  // to undone, redoing moves them in the other direction.\n  this.done = []; this.undone = []\n  this.undoDepth = Infinity\n  // Used to track when changes can be merged into a single undo\n  // event\n  this.lastModTime = this.lastSelTime = 0\n  this.lastOp = this.lastSelOp = null\n  this.lastOrigin = this.lastSelOrigin = null\n  // Used by the isClean() method\n  this.generation = this.maxGeneration = startGen || 1\n}\n\n// Create a history change event from an updateDoc-style change\n// object.\nfunction historyChangeFromChange(doc, change) {\n  var histChange = {from: copyPos(change.from), to: changeEnd(change), text: getBetween(doc, change.from, change.to)}\n  attachLocalSpans(doc, histChange, change.from.line, change.to.line + 1)\n  linkedDocs(doc, function (doc) { return attachLocalSpans(doc, histChange, change.from.line, change.to.line + 1); }, true)\n  return histChange\n}\n\n// Pop all selection events off the end of a history array. Stop at\n// a change event.\nfunction clearSelectionEvents(array) {\n  while (array.length) {\n    var last = lst(array)\n    if (last.ranges) { array.pop() }\n    else { break }\n  }\n}\n\n// Find the top change event in the history. Pop off selection\n// events that are in the way.\nfunction lastChangeEvent(hist, force) {\n  if (force) {\n    clearSelectionEvents(hist.done)\n    return lst(hist.done)\n  } else if (hist.done.length && !lst(hist.done).ranges) {\n    return lst(hist.done)\n  } else if (hist.done.length > 1 && !hist.done[hist.done.length - 2].ranges) {\n    hist.done.pop()\n    return lst(hist.done)\n  }\n}\n\n// Register a change in the history. Merges changes that are within\n// a single operation, or are close together with an origin that\n// allows merging (starting with \"+\") into a single event.\nfunction addChangeToHistory(doc, change, selAfter, opId) {\n  var hist = doc.history\n  hist.undone.length = 0\n  var time = +new Date, cur\n  var last\n\n  if ((hist.lastOp == opId ||\n       hist.lastOrigin == change.origin && change.origin &&\n       ((change.origin.charAt(0) == \"+\" && doc.cm && hist.lastModTime > time - doc.cm.options.historyEventDelay) ||\n        change.origin.charAt(0) == \"*\")) &&\n      (cur = lastChangeEvent(hist, hist.lastOp == opId))) {\n    // Merge this change into the last event\n    last = lst(cur.changes)\n    if (cmp(change.from, change.to) == 0 && cmp(change.from, last.to) == 0) {\n      // Optimized case for simple insertion -- don't want to add\n      // new changesets for every character typed\n      last.to = changeEnd(change)\n    } else {\n      // Add new sub-event\n      cur.changes.push(historyChangeFromChange(doc, change))\n    }\n  } else {\n    // Can not be merged, start a new event.\n    var before = lst(hist.done)\n    if (!before || !before.ranges)\n      { pushSelectionToHistory(doc.sel, hist.done) }\n    cur = {changes: [historyChangeFromChange(doc, change)],\n           generation: hist.generation}\n    hist.done.push(cur)\n    while (hist.done.length > hist.undoDepth) {\n      hist.done.shift()\n      if (!hist.done[0].ranges) { hist.done.shift() }\n    }\n  }\n  hist.done.push(selAfter)\n  hist.generation = ++hist.maxGeneration\n  hist.lastModTime = hist.lastSelTime = time\n  hist.lastOp = hist.lastSelOp = opId\n  hist.lastOrigin = hist.lastSelOrigin = change.origin\n\n  if (!last) { signal(doc, \"historyAdded\") }\n}\n\nfunction selectionEventCanBeMerged(doc, origin, prev, sel) {\n  var ch = origin.charAt(0)\n  return ch == \"*\" ||\n    ch == \"+\" &&\n    prev.ranges.length == sel.ranges.length &&\n    prev.somethingSelected() == sel.somethingSelected() &&\n    new Date - doc.history.lastSelTime <= (doc.cm ? doc.cm.options.historyEventDelay : 500)\n}\n\n// Called whenever the selection changes, sets the new selection as\n// the pending selection in the history, and pushes the old pending\n// selection into the 'done' array when it was significantly\n// different (in number of selected ranges, emptiness, or time).\nfunction addSelectionToHistory(doc, sel, opId, options) {\n  var hist = doc.history, origin = options && options.origin\n\n  // A new event is started when the previous origin does not match\n  // the current, or the origins don't allow matching. Origins\n  // starting with * are always merged, those starting with + are\n  // merged when similar and close together in time.\n  if (opId == hist.lastSelOp ||\n      (origin && hist.lastSelOrigin == origin &&\n       (hist.lastModTime == hist.lastSelTime && hist.lastOrigin == origin ||\n        selectionEventCanBeMerged(doc, origin, lst(hist.done), sel))))\n    { hist.done[hist.done.length - 1] = sel }\n  else\n    { pushSelectionToHistory(sel, hist.done) }\n\n  hist.lastSelTime = +new Date\n  hist.lastSelOrigin = origin\n  hist.lastSelOp = opId\n  if (options && options.clearRedo !== false)\n    { clearSelectionEvents(hist.undone) }\n}\n\nfunction pushSelectionToHistory(sel, dest) {\n  var top = lst(dest)\n  if (!(top && top.ranges && top.equals(sel)))\n    { dest.push(sel) }\n}\n\n// Used to store marked span information in the history.\nfunction attachLocalSpans(doc, change, from, to) {\n  var existing = change[\"spans_\" + doc.id], n = 0\n  doc.iter(Math.max(doc.first, from), Math.min(doc.first + doc.size, to), function (line) {\n    if (line.markedSpans)\n      { (existing || (existing = change[\"spans_\" + doc.id] = {}))[n] = line.markedSpans }\n    ++n\n  })\n}\n\n// When un/re-doing restores text containing marked spans, those\n// that have been explicitly cleared should not be restored.\nfunction removeClearedSpans(spans) {\n  if (!spans) { return null }\n  var out\n  for (var i = 0; i < spans.length; ++i) {\n    if (spans[i].marker.explicitlyCleared) { if (!out) { out = spans.slice(0, i) } }\n    else if (out) { out.push(spans[i]) }\n  }\n  return !out ? spans : out.length ? out : null\n}\n\n// Retrieve and filter the old marked spans stored in a change event.\nfunction getOldSpans(doc, change) {\n  var found = change[\"spans_\" + doc.id]\n  if (!found) { return null }\n  var nw = []\n  for (var i = 0; i < change.text.length; ++i)\n    { nw.push(removeClearedSpans(found[i])) }\n  return nw\n}\n\n// Used for un/re-doing changes from the history. Combines the\n// result of computing the existing spans with the set of spans that\n// existed in the history (so that deleting around a span and then\n// undoing brings back the span).\nfunction mergeOldSpans(doc, change) {\n  var old = getOldSpans(doc, change)\n  var stretched = stretchSpansOverChange(doc, change)\n  if (!old) { return stretched }\n  if (!stretched) { return old }\n\n  for (var i = 0; i < old.length; ++i) {\n    var oldCur = old[i], stretchCur = stretched[i]\n    if (oldCur && stretchCur) {\n      spans: for (var j = 0; j < stretchCur.length; ++j) {\n        var span = stretchCur[j]\n        for (var k = 0; k < oldCur.length; ++k)\n          { if (oldCur[k].marker == span.marker) { continue spans } }\n        oldCur.push(span)\n      }\n    } else if (stretchCur) {\n      old[i] = stretchCur\n    }\n  }\n  return old\n}\n\n// Used both to provide a JSON-safe object in .getHistory, and, when\n// detaching a document, to split the history in two\nfunction copyHistoryArray(events, newGroup, instantiateSel) {\n  var copy = []\n  for (var i = 0; i < events.length; ++i) {\n    var event = events[i]\n    if (event.ranges) {\n      copy.push(instantiateSel ? Selection.prototype.deepCopy.call(event) : event)\n      continue\n    }\n    var changes = event.changes, newChanges = []\n    copy.push({changes: newChanges})\n    for (var j = 0; j < changes.length; ++j) {\n      var change = changes[j], m = (void 0)\n      newChanges.push({from: change.from, to: change.to, text: change.text})\n      if (newGroup) { for (var prop in change) { if (m = prop.match(/^spans_(\\d+)$/)) {\n        if (indexOf(newGroup, Number(m[1])) > -1) {\n          lst(newChanges)[prop] = change[prop]\n          delete change[prop]\n        }\n      } } }\n    }\n  }\n  return copy\n}\n\n// The 'scroll' parameter given to many of these indicated whether\n// the new cursor position should be scrolled into view after\n// modifying the selection.\n\n// If shift is held or the extend flag is set, extends a range to\n// include a given position (and optionally a second position).\n// Otherwise, simply returns the range between the given positions.\n// Used for cursor motion and such.\nfunction extendRange(doc, range, head, other) {\n  if (doc.cm && doc.cm.display.shift || doc.extend) {\n    var anchor = range.anchor\n    if (other) {\n      var posBefore = cmp(head, anchor) < 0\n      if (posBefore != (cmp(other, anchor) < 0)) {\n        anchor = head\n        head = other\n      } else if (posBefore != (cmp(head, other) < 0)) {\n        head = other\n      }\n    }\n    return new Range(anchor, head)\n  } else {\n    return new Range(other || head, head)\n  }\n}\n\n// Extend the primary selection range, discard the rest.\nfunction extendSelection(doc, head, other, options) {\n  setSelection(doc, new Selection([extendRange(doc, doc.sel.primary(), head, other)], 0), options)\n}\n\n// Extend all selections (pos is an array of selections with length\n// equal the number of selections)\nfunction extendSelections(doc, heads, options) {\n  var out = []\n  for (var i = 0; i < doc.sel.ranges.length; i++)\n    { out[i] = extendRange(doc, doc.sel.ranges[i], heads[i], null) }\n  var newSel = normalizeSelection(out, doc.sel.primIndex)\n  setSelection(doc, newSel, options)\n}\n\n// Updates a single range in the selection.\nfunction replaceOneSelection(doc, i, range, options) {\n  var ranges = doc.sel.ranges.slice(0)\n  ranges[i] = range\n  setSelection(doc, normalizeSelection(ranges, doc.sel.primIndex), options)\n}\n\n// Reset the selection to a single range.\nfunction setSimpleSelection(doc, anchor, head, options) {\n  setSelection(doc, simpleSelection(anchor, head), options)\n}\n\n// Give beforeSelectionChange handlers a change to influence a\n// selection update.\nfunction filterSelectionChange(doc, sel, options) {\n  var obj = {\n    ranges: sel.ranges,\n    update: function(ranges) {\n      var this$1 = this;\n\n      this.ranges = []\n      for (var i = 0; i < ranges.length; i++)\n        { this$1.ranges[i] = new Range(clipPos(doc, ranges[i].anchor),\n                                   clipPos(doc, ranges[i].head)) }\n    },\n    origin: options && options.origin\n  }\n  signal(doc, \"beforeSelectionChange\", doc, obj)\n  if (doc.cm) { signal(doc.cm, \"beforeSelectionChange\", doc.cm, obj) }\n  if (obj.ranges != sel.ranges) { return normalizeSelection(obj.ranges, obj.ranges.length - 1) }\n  else { return sel }\n}\n\nfunction setSelectionReplaceHistory(doc, sel, options) {\n  var done = doc.history.done, last = lst(done)\n  if (last && last.ranges) {\n    done[done.length - 1] = sel\n    setSelectionNoUndo(doc, sel, options)\n  } else {\n    setSelection(doc, sel, options)\n  }\n}\n\n// Set a new selection.\nfunction setSelection(doc, sel, options) {\n  setSelectionNoUndo(doc, sel, options)\n  addSelectionToHistory(doc, doc.sel, doc.cm ? doc.cm.curOp.id : NaN, options)\n}\n\nfunction setSelectionNoUndo(doc, sel, options) {\n  if (hasHandler(doc, \"beforeSelectionChange\") || doc.cm && hasHandler(doc.cm, \"beforeSelectionChange\"))\n    { sel = filterSelectionChange(doc, sel, options) }\n\n  var bias = options && options.bias ||\n    (cmp(sel.primary().head, doc.sel.primary().head) < 0 ? -1 : 1)\n  setSelectionInner(doc, skipAtomicInSelection(doc, sel, bias, true))\n\n  if (!(options && options.scroll === false) && doc.cm)\n    { ensureCursorVisible(doc.cm) }\n}\n\nfunction setSelectionInner(doc, sel) {\n  if (sel.equals(doc.sel)) { return }\n\n  doc.sel = sel\n\n  if (doc.cm) {\n    doc.cm.curOp.updateInput = doc.cm.curOp.selectionChanged = true\n    signalCursorActivity(doc.cm)\n  }\n  signalLater(doc, \"cursorActivity\", doc)\n}\n\n// Verify that the selection does not partially select any atomic\n// marked ranges.\nfunction reCheckSelection(doc) {\n  setSelectionInner(doc, skipAtomicInSelection(doc, doc.sel, null, false), sel_dontScroll)\n}\n\n// Return a selection that does not partially select any atomic\n// ranges.\nfunction skipAtomicInSelection(doc, sel, bias, mayClear) {\n  var out\n  for (var i = 0; i < sel.ranges.length; i++) {\n    var range = sel.ranges[i]\n    var old = sel.ranges.length == doc.sel.ranges.length && doc.sel.ranges[i]\n    var newAnchor = skipAtomic(doc, range.anchor, old && old.anchor, bias, mayClear)\n    var newHead = skipAtomic(doc, range.head, old && old.head, bias, mayClear)\n    if (out || newAnchor != range.anchor || newHead != range.head) {\n      if (!out) { out = sel.ranges.slice(0, i) }\n      out[i] = new Range(newAnchor, newHead)\n    }\n  }\n  return out ? normalizeSelection(out, sel.primIndex) : sel\n}\n\nfunction skipAtomicInner(doc, pos, oldPos, dir, mayClear) {\n  var line = getLine(doc, pos.line)\n  if (line.markedSpans) { for (var i = 0; i < line.markedSpans.length; ++i) {\n    var sp = line.markedSpans[i], m = sp.marker\n    if ((sp.from == null || (m.inclusiveLeft ? sp.from <= pos.ch : sp.from < pos.ch)) &&\n        (sp.to == null || (m.inclusiveRight ? sp.to >= pos.ch : sp.to > pos.ch))) {\n      if (mayClear) {\n        signal(m, \"beforeCursorEnter\")\n        if (m.explicitlyCleared) {\n          if (!line.markedSpans) { break }\n          else {--i; continue}\n        }\n      }\n      if (!m.atomic) { continue }\n\n      if (oldPos) {\n        var near = m.find(dir < 0 ? 1 : -1), diff = (void 0)\n        if (dir < 0 ? m.inclusiveRight : m.inclusiveLeft)\n          { near = movePos(doc, near, -dir, near && near.line == pos.line ? line : null) }\n        if (near && near.line == pos.line && (diff = cmp(near, oldPos)) && (dir < 0 ? diff < 0 : diff > 0))\n          { return skipAtomicInner(doc, near, pos, dir, mayClear) }\n      }\n\n      var far = m.find(dir < 0 ? -1 : 1)\n      if (dir < 0 ? m.inclusiveLeft : m.inclusiveRight)\n        { far = movePos(doc, far, dir, far.line == pos.line ? line : null) }\n      return far ? skipAtomicInner(doc, far, pos, dir, mayClear) : null\n    }\n  } }\n  return pos\n}\n\n// Ensure a given position is not inside an atomic range.\nfunction skipAtomic(doc, pos, oldPos, bias, mayClear) {\n  var dir = bias || 1\n  var found = skipAtomicInner(doc, pos, oldPos, dir, mayClear) ||\n      (!mayClear && skipAtomicInner(doc, pos, oldPos, dir, true)) ||\n      skipAtomicInner(doc, pos, oldPos, -dir, mayClear) ||\n      (!mayClear && skipAtomicInner(doc, pos, oldPos, -dir, true))\n  if (!found) {\n    doc.cantEdit = true\n    return Pos(doc.first, 0)\n  }\n  return found\n}\n\nfunction movePos(doc, pos, dir, line) {\n  if (dir < 0 && pos.ch == 0) {\n    if (pos.line > doc.first) { return clipPos(doc, Pos(pos.line - 1)) }\n    else { return null }\n  } else if (dir > 0 && pos.ch == (line || getLine(doc, pos.line)).text.length) {\n    if (pos.line < doc.first + doc.size - 1) { return Pos(pos.line + 1, 0) }\n    else { return null }\n  } else {\n    return new Pos(pos.line, pos.ch + dir)\n  }\n}\n\nfunction selectAll(cm) {\n  cm.setSelection(Pos(cm.firstLine(), 0), Pos(cm.lastLine()), sel_dontScroll)\n}\n\n// UPDATING\n\n// Allow \"beforeChange\" event handlers to influence a change\nfunction filterChange(doc, change, update) {\n  var obj = {\n    canceled: false,\n    from: change.from,\n    to: change.to,\n    text: change.text,\n    origin: change.origin,\n    cancel: function () { return obj.canceled = true; }\n  }\n  if (update) { obj.update = function (from, to, text, origin) {\n    if (from) { obj.from = clipPos(doc, from) }\n    if (to) { obj.to = clipPos(doc, to) }\n    if (text) { obj.text = text }\n    if (origin !== undefined) { obj.origin = origin }\n  } }\n  signal(doc, \"beforeChange\", doc, obj)\n  if (doc.cm) { signal(doc.cm, \"beforeChange\", doc.cm, obj) }\n\n  if (obj.canceled) { return null }\n  return {from: obj.from, to: obj.to, text: obj.text, origin: obj.origin}\n}\n\n// Apply a change to a document, and add it to the document's\n// history, and propagating it to all linked documents.\nfunction makeChange(doc, change, ignoreReadOnly) {\n  if (doc.cm) {\n    if (!doc.cm.curOp) { return operation(doc.cm, makeChange)(doc, change, ignoreReadOnly) }\n    if (doc.cm.state.suppressEdits) { return }\n  }\n\n  if (hasHandler(doc, \"beforeChange\") || doc.cm && hasHandler(doc.cm, \"beforeChange\")) {\n    change = filterChange(doc, change, true)\n    if (!change) { return }\n  }\n\n  // Possibly split or suppress the update based on the presence\n  // of read-only spans in its range.\n  var split = sawReadOnlySpans && !ignoreReadOnly && removeReadOnlyRanges(doc, change.from, change.to)\n  if (split) {\n    for (var i = split.length - 1; i >= 0; --i)\n      { makeChangeInner(doc, {from: split[i].from, to: split[i].to, text: i ? [\"\"] : change.text}) }\n  } else {\n    makeChangeInner(doc, change)\n  }\n}\n\nfunction makeChangeInner(doc, change) {\n  if (change.text.length == 1 && change.text[0] == \"\" && cmp(change.from, change.to) == 0) { return }\n  var selAfter = computeSelAfterChange(doc, change)\n  addChangeToHistory(doc, change, selAfter, doc.cm ? doc.cm.curOp.id : NaN)\n\n  makeChangeSingleDoc(doc, change, selAfter, stretchSpansOverChange(doc, change))\n  var rebased = []\n\n  linkedDocs(doc, function (doc, sharedHist) {\n    if (!sharedHist && indexOf(rebased, doc.history) == -1) {\n      rebaseHist(doc.history, change)\n      rebased.push(doc.history)\n    }\n    makeChangeSingleDoc(doc, change, null, stretchSpansOverChange(doc, change))\n  })\n}\n\n// Revert a change stored in a document's history.\nfunction makeChangeFromHistory(doc, type, allowSelectionOnly) {\n  if (doc.cm && doc.cm.state.suppressEdits && !allowSelectionOnly) { return }\n\n  var hist = doc.history, event, selAfter = doc.sel\n  var source = type == \"undo\" ? hist.done : hist.undone, dest = type == \"undo\" ? hist.undone : hist.done\n\n  // Verify that there is a useable event (so that ctrl-z won't\n  // needlessly clear selection events)\n  var i = 0\n  for (; i < source.length; i++) {\n    event = source[i]\n    if (allowSelectionOnly ? event.ranges && !event.equals(doc.sel) : !event.ranges)\n      { break }\n  }\n  if (i == source.length) { return }\n  hist.lastOrigin = hist.lastSelOrigin = null\n\n  for (;;) {\n    event = source.pop()\n    if (event.ranges) {\n      pushSelectionToHistory(event, dest)\n      if (allowSelectionOnly && !event.equals(doc.sel)) {\n        setSelection(doc, event, {clearRedo: false})\n        return\n      }\n      selAfter = event\n    }\n    else { break }\n  }\n\n  // Build up a reverse change object to add to the opposite history\n  // stack (redo when undoing, and vice versa).\n  var antiChanges = []\n  pushSelectionToHistory(selAfter, dest)\n  dest.push({changes: antiChanges, generation: hist.generation})\n  hist.generation = event.generation || ++hist.maxGeneration\n\n  var filter = hasHandler(doc, \"beforeChange\") || doc.cm && hasHandler(doc.cm, \"beforeChange\")\n\n  var loop = function ( i ) {\n    var change = event.changes[i]\n    change.origin = type\n    if (filter && !filterChange(doc, change, false)) {\n      source.length = 0\n      return {}\n    }\n\n    antiChanges.push(historyChangeFromChange(doc, change))\n\n    var after = i ? computeSelAfterChange(doc, change) : lst(source)\n    makeChangeSingleDoc(doc, change, after, mergeOldSpans(doc, change))\n    if (!i && doc.cm) { doc.cm.scrollIntoView({from: change.from, to: changeEnd(change)}) }\n    var rebased = []\n\n    // Propagate to the linked documents\n    linkedDocs(doc, function (doc, sharedHist) {\n      if (!sharedHist && indexOf(rebased, doc.history) == -1) {\n        rebaseHist(doc.history, change)\n        rebased.push(doc.history)\n      }\n      makeChangeSingleDoc(doc, change, null, mergeOldSpans(doc, change))\n    })\n  };\n\n  for (var i$1 = event.changes.length - 1; i$1 >= 0; --i$1) {\n    var returned = loop( i$1 );\n\n    if ( returned ) return returned.v;\n  }\n}\n\n// Sub-views need their line numbers shifted when text is added\n// above or below them in the parent document.\nfunction shiftDoc(doc, distance) {\n  if (distance == 0) { return }\n  doc.first += distance\n  doc.sel = new Selection(map(doc.sel.ranges, function (range) { return new Range(\n    Pos(range.anchor.line + distance, range.anchor.ch),\n    Pos(range.head.line + distance, range.head.ch)\n  ); }), doc.sel.primIndex)\n  if (doc.cm) {\n    regChange(doc.cm, doc.first, doc.first - distance, distance)\n    for (var d = doc.cm.display, l = d.viewFrom; l < d.viewTo; l++)\n      { regLineChange(doc.cm, l, \"gutter\") }\n  }\n}\n\n// More lower-level change function, handling only a single document\n// (not linked ones).\nfunction makeChangeSingleDoc(doc, change, selAfter, spans) {\n  if (doc.cm && !doc.cm.curOp)\n    { return operation(doc.cm, makeChangeSingleDoc)(doc, change, selAfter, spans) }\n\n  if (change.to.line < doc.first) {\n    shiftDoc(doc, change.text.length - 1 - (change.to.line - change.from.line))\n    return\n  }\n  if (change.from.line > doc.lastLine()) { return }\n\n  // Clip the change to the size of this doc\n  if (change.from.line < doc.first) {\n    var shift = change.text.length - 1 - (doc.first - change.from.line)\n    shiftDoc(doc, shift)\n    change = {from: Pos(doc.first, 0), to: Pos(change.to.line + shift, change.to.ch),\n              text: [lst(change.text)], origin: change.origin}\n  }\n  var last = doc.lastLine()\n  if (change.to.line > last) {\n    change = {from: change.from, to: Pos(last, getLine(doc, last).text.length),\n              text: [change.text[0]], origin: change.origin}\n  }\n\n  change.removed = getBetween(doc, change.from, change.to)\n\n  if (!selAfter) { selAfter = computeSelAfterChange(doc, change) }\n  if (doc.cm) { makeChangeSingleDocInEditor(doc.cm, change, spans) }\n  else { updateDoc(doc, change, spans) }\n  setSelectionNoUndo(doc, selAfter, sel_dontScroll)\n}\n\n// Handle the interaction of a change to a document with the editor\n// that this document is part of.\nfunction makeChangeSingleDocInEditor(cm, change, spans) {\n  var doc = cm.doc, display = cm.display, from = change.from, to = change.to\n\n  var recomputeMaxLength = false, checkWidthStart = from.line\n  if (!cm.options.lineWrapping) {\n    checkWidthStart = lineNo(visualLine(getLine(doc, from.line)))\n    doc.iter(checkWidthStart, to.line + 1, function (line) {\n      if (line == display.maxLine) {\n        recomputeMaxLength = true\n        return true\n      }\n    })\n  }\n\n  if (doc.sel.contains(change.from, change.to) > -1)\n    { signalCursorActivity(cm) }\n\n  updateDoc(doc, change, spans, estimateHeight(cm))\n\n  if (!cm.options.lineWrapping) {\n    doc.iter(checkWidthStart, from.line + change.text.length, function (line) {\n      var len = lineLength(line)\n      if (len > display.maxLineLength) {\n        display.maxLine = line\n        display.maxLineLength = len\n        display.maxLineChanged = true\n        recomputeMaxLength = false\n      }\n    })\n    if (recomputeMaxLength) { cm.curOp.updateMaxLine = true }\n  }\n\n  // Adjust frontier, schedule worker\n  doc.frontier = Math.min(doc.frontier, from.line)\n  startWorker(cm, 400)\n\n  var lendiff = change.text.length - (to.line - from.line) - 1\n  // Remember that these lines changed, for updating the display\n  if (change.full)\n    { regChange(cm) }\n  else if (from.line == to.line && change.text.length == 1 && !isWholeLineUpdate(cm.doc, change))\n    { regLineChange(cm, from.line, \"text\") }\n  else\n    { regChange(cm, from.line, to.line + 1, lendiff) }\n\n  var changesHandler = hasHandler(cm, \"changes\"), changeHandler = hasHandler(cm, \"change\")\n  if (changeHandler || changesHandler) {\n    var obj = {\n      from: from, to: to,\n      text: change.text,\n      removed: change.removed,\n      origin: change.origin\n    }\n    if (changeHandler) { signalLater(cm, \"change\", cm, obj) }\n    if (changesHandler) { (cm.curOp.changeObjs || (cm.curOp.changeObjs = [])).push(obj) }\n  }\n  cm.display.selForContextMenu = null\n}\n\nfunction replaceRange(doc, code, from, to, origin) {\n  if (!to) { to = from }\n  if (cmp(to, from) < 0) { var tmp = to; to = from; from = tmp }\n  if (typeof code == \"string\") { code = doc.splitLines(code) }\n  makeChange(doc, {from: from, to: to, text: code, origin: origin})\n}\n\n// Rebasing/resetting history to deal with externally-sourced changes\n\nfunction rebaseHistSelSingle(pos, from, to, diff) {\n  if (to < pos.line) {\n    pos.line += diff\n  } else if (from < pos.line) {\n    pos.line = from\n    pos.ch = 0\n  }\n}\n\n// Tries to rebase an array of history events given a change in the\n// document. If the change touches the same lines as the event, the\n// event, and everything 'behind' it, is discarded. If the change is\n// before the event, the event's positions are updated. Uses a\n// copy-on-write scheme for the positions, to avoid having to\n// reallocate them all on every rebase, but also avoid problems with\n// shared position objects being unsafely updated.\nfunction rebaseHistArray(array, from, to, diff) {\n  for (var i = 0; i < array.length; ++i) {\n    var sub = array[i], ok = true\n    if (sub.ranges) {\n      if (!sub.copied) { sub = array[i] = sub.deepCopy(); sub.copied = true }\n      for (var j = 0; j < sub.ranges.length; j++) {\n        rebaseHistSelSingle(sub.ranges[j].anchor, from, to, diff)\n        rebaseHistSelSingle(sub.ranges[j].head, from, to, diff)\n      }\n      continue\n    }\n    for (var j$1 = 0; j$1 < sub.changes.length; ++j$1) {\n      var cur = sub.changes[j$1]\n      if (to < cur.from.line) {\n        cur.from = Pos(cur.from.line + diff, cur.from.ch)\n        cur.to = Pos(cur.to.line + diff, cur.to.ch)\n      } else if (from <= cur.to.line) {\n        ok = false\n        break\n      }\n    }\n    if (!ok) {\n      array.splice(0, i + 1)\n      i = 0\n    }\n  }\n}\n\nfunction rebaseHist(hist, change) {\n  var from = change.from.line, to = change.to.line, diff = change.text.length - (to - from) - 1\n  rebaseHistArray(hist.done, from, to, diff)\n  rebaseHistArray(hist.undone, from, to, diff)\n}\n\n// Utility for applying a change to a line by handle or number,\n// returning the number and optionally registering the line as\n// changed.\nfunction changeLine(doc, handle, changeType, op) {\n  var no = handle, line = handle\n  if (typeof handle == \"number\") { line = getLine(doc, clipLine(doc, handle)) }\n  else { no = lineNo(handle) }\n  if (no == null) { return null }\n  if (op(line, no) && doc.cm) { regLineChange(doc.cm, no, changeType) }\n  return line\n}\n\n// The document is represented as a BTree consisting of leaves, with\n// chunk of lines in them, and branches, with up to ten leaves or\n// other branch nodes below them. The top node is always a branch\n// node, and is the document object itself (meaning it has\n// additional methods and properties).\n//\n// All nodes have parent links. The tree is used both to go from\n// line numbers to line objects, and to go from objects to numbers.\n// It also indexes by height, and is used to convert between height\n// and line object, and to find the total height of the document.\n//\n// See also http://marijnhaverbeke.nl/blog/codemirror-line-tree.html\n\nvar LeafChunk = function(lines) {\n  var this$1 = this;\n\n  this.lines = lines\n  this.parent = null\n  var height = 0\n  for (var i = 0; i < lines.length; ++i) {\n    lines[i].parent = this$1\n    height += lines[i].height\n  }\n  this.height = height\n};\n\nLeafChunk.prototype.chunkSize = function () { return this.lines.length };\n\n// Remove the n lines at offset 'at'.\nLeafChunk.prototype.removeInner = function (at, n) {\n    var this$1 = this;\n\n  for (var i = at, e = at + n; i < e; ++i) {\n    var line = this$1.lines[i]\n    this$1.height -= line.height\n    cleanUpLine(line)\n    signalLater(line, \"delete\")\n  }\n  this.lines.splice(at, n)\n};\n\n// Helper used to collapse a small branch into a single leaf.\nLeafChunk.prototype.collapse = function (lines) {\n  lines.push.apply(lines, this.lines)\n};\n\n// Insert the given array of lines at offset 'at', count them as\n// having the given height.\nLeafChunk.prototype.insertInner = function (at, lines, height) {\n    var this$1 = this;\n\n  this.height += height\n  this.lines = this.lines.slice(0, at).concat(lines).concat(this.lines.slice(at))\n  for (var i = 0; i < lines.length; ++i) { lines[i].parent = this$1 }\n};\n\n// Used to iterate over a part of the tree.\nLeafChunk.prototype.iterN = function (at, n, op) {\n    var this$1 = this;\n\n  for (var e = at + n; at < e; ++at)\n    { if (op(this$1.lines[at])) { return true } }\n};\n\nvar BranchChunk = function(children) {\n  var this$1 = this;\n\n  this.children = children\n  var size = 0, height = 0\n  for (var i = 0; i < children.length; ++i) {\n    var ch = children[i]\n    size += ch.chunkSize(); height += ch.height\n    ch.parent = this$1\n  }\n  this.size = size\n  this.height = height\n  this.parent = null\n};\n\nBranchChunk.prototype.chunkSize = function () { return this.size };\n\nBranchChunk.prototype.removeInner = function (at, n) {\n    var this$1 = this;\n\n  this.size -= n\n  for (var i = 0; i < this.children.length; ++i) {\n    var child = this$1.children[i], sz = child.chunkSize()\n    if (at < sz) {\n      var rm = Math.min(n, sz - at), oldHeight = child.height\n      child.removeInner(at, rm)\n      this$1.height -= oldHeight - child.height\n      if (sz == rm) { this$1.children.splice(i--, 1); child.parent = null }\n      if ((n -= rm) == 0) { break }\n      at = 0\n    } else { at -= sz }\n  }\n  // If the result is smaller than 25 lines, ensure that it is a\n  // single leaf node.\n  if (this.size - n < 25 &&\n      (this.children.length > 1 || !(this.children[0] instanceof LeafChunk))) {\n    var lines = []\n    this.collapse(lines)\n    this.children = [new LeafChunk(lines)]\n    this.children[0].parent = this\n  }\n};\n\nBranchChunk.prototype.collapse = function (lines) {\n    var this$1 = this;\n\n  for (var i = 0; i < this.children.length; ++i) { this$1.children[i].collapse(lines) }\n};\n\nBranchChunk.prototype.insertInner = function (at, lines, height) {\n    var this$1 = this;\n\n  this.size += lines.length\n  this.height += height\n  for (var i = 0; i < this.children.length; ++i) {\n    var child = this$1.children[i], sz = child.chunkSize()\n    if (at <= sz) {\n      child.insertInner(at, lines, height)\n      if (child.lines && child.lines.length > 50) {\n        // To avoid memory thrashing when child.lines is huge (e.g. first view of a large file), it's never spliced.\n        // Instead, small slices are taken. They're taken in order because sequential memory accesses are fastest.\n        var remaining = child.lines.length % 25 + 25\n        for (var pos = remaining; pos < child.lines.length;) {\n          var leaf = new LeafChunk(child.lines.slice(pos, pos += 25))\n          child.height -= leaf.height\n          this$1.children.splice(++i, 0, leaf)\n          leaf.parent = this$1\n        }\n        child.lines = child.lines.slice(0, remaining)\n        this$1.maybeSpill()\n      }\n      break\n    }\n    at -= sz\n  }\n};\n\n// When a node has grown, check whether it should be split.\nBranchChunk.prototype.maybeSpill = function () {\n  if (this.children.length <= 10) { return }\n  var me = this\n  do {\n    var spilled = me.children.splice(me.children.length - 5, 5)\n    var sibling = new BranchChunk(spilled)\n    if (!me.parent) { // Become the parent node\n      var copy = new BranchChunk(me.children)\n      copy.parent = me\n      me.children = [copy, sibling]\n      me = copy\n   } else {\n      me.size -= sibling.size\n      me.height -= sibling.height\n      var myIndex = indexOf(me.parent.children, me)\n      me.parent.children.splice(myIndex + 1, 0, sibling)\n    }\n    sibling.parent = me.parent\n  } while (me.children.length > 10)\n  me.parent.maybeSpill()\n};\n\nBranchChunk.prototype.iterN = function (at, n, op) {\n    var this$1 = this;\n\n  for (var i = 0; i < this.children.length; ++i) {\n    var child = this$1.children[i], sz = child.chunkSize()\n    if (at < sz) {\n      var used = Math.min(n, sz - at)\n      if (child.iterN(at, used, op)) { return true }\n      if ((n -= used) == 0) { break }\n      at = 0\n    } else { at -= sz }\n  }\n};\n\n// Line widgets are block elements displayed above or below a line.\n\nvar LineWidget = function(doc, node, options) {\n  var this$1 = this;\n\n  if (options) { for (var opt in options) { if (options.hasOwnProperty(opt))\n    { this$1[opt] = options[opt] } } }\n  this.doc = doc\n  this.node = node\n};\n\nLineWidget.prototype.clear = function () {\n    var this$1 = this;\n\n  var cm = this.doc.cm, ws = this.line.widgets, line = this.line, no = lineNo(line)\n  if (no == null || !ws) { return }\n  for (var i = 0; i < ws.length; ++i) { if (ws[i] == this$1) { ws.splice(i--, 1) } }\n  if (!ws.length) { line.widgets = null }\n  var height = widgetHeight(this)\n  updateLineHeight(line, Math.max(0, line.height - height))\n  if (cm) {\n    runInOp(cm, function () {\n      adjustScrollWhenAboveVisible(cm, line, -height)\n      regLineChange(cm, no, \"widget\")\n    })\n    signalLater(cm, \"lineWidgetCleared\", cm, this, no)\n  }\n};\n\nLineWidget.prototype.changed = function () {\n    var this$1 = this;\n\n  var oldH = this.height, cm = this.doc.cm, line = this.line\n  this.height = null\n  var diff = widgetHeight(this) - oldH\n  if (!diff) { return }\n  updateLineHeight(line, line.height + diff)\n  if (cm) {\n    runInOp(cm, function () {\n      cm.curOp.forceUpdate = true\n      adjustScrollWhenAboveVisible(cm, line, diff)\n      signalLater(cm, \"lineWidgetChanged\", cm, this$1, lineNo(line))\n    })\n  }\n};\neventMixin(LineWidget)\n\nfunction adjustScrollWhenAboveVisible(cm, line, diff) {\n  if (heightAtLine(line) < ((cm.curOp && cm.curOp.scrollTop) || cm.doc.scrollTop))\n    { addToScrollPos(cm, null, diff) }\n}\n\nfunction addLineWidget(doc, handle, node, options) {\n  var widget = new LineWidget(doc, node, options)\n  var cm = doc.cm\n  if (cm && widget.noHScroll) { cm.display.alignWidgets = true }\n  changeLine(doc, handle, \"widget\", function (line) {\n    var widgets = line.widgets || (line.widgets = [])\n    if (widget.insertAt == null) { widgets.push(widget) }\n    else { widgets.splice(Math.min(widgets.length - 1, Math.max(0, widget.insertAt)), 0, widget) }\n    widget.line = line\n    if (cm && !lineIsHidden(doc, line)) {\n      var aboveVisible = heightAtLine(line) < doc.scrollTop\n      updateLineHeight(line, line.height + widgetHeight(widget))\n      if (aboveVisible) { addToScrollPos(cm, null, widget.height) }\n      cm.curOp.forceUpdate = true\n    }\n    return true\n  })\n  signalLater(cm, \"lineWidgetAdded\", cm, widget, typeof handle == \"number\" ? handle : lineNo(handle))\n  return widget\n}\n\n// TEXTMARKERS\n\n// Created with markText and setBookmark methods. A TextMarker is a\n// handle that can be used to clear or find a marked position in the\n// document. Line objects hold arrays (markedSpans) containing\n// {from, to, marker} object pointing to such marker objects, and\n// indicating that such a marker is present on that line. Multiple\n// lines may point to the same marker when it spans across lines.\n// The spans will have null for their from/to properties when the\n// marker continues beyond the start/end of the line. Markers have\n// links back to the lines they currently touch.\n\n// Collapsed markers have unique ids, in order to be able to order\n// them, which is needed for uniquely determining an outer marker\n// when they overlap (they may nest, but not partially overlap).\nvar nextMarkerId = 0\n\nvar TextMarker = function(doc, type) {\n  this.lines = []\n  this.type = type\n  this.doc = doc\n  this.id = ++nextMarkerId\n};\n\n// Clear the marker.\nTextMarker.prototype.clear = function () {\n    var this$1 = this;\n\n  if (this.explicitlyCleared) { return }\n  var cm = this.doc.cm, withOp = cm && !cm.curOp\n  if (withOp) { startOperation(cm) }\n  if (hasHandler(this, \"clear\")) {\n    var found = this.find()\n    if (found) { signalLater(this, \"clear\", found.from, found.to) }\n  }\n  var min = null, max = null\n  for (var i = 0; i < this.lines.length; ++i) {\n    var line = this$1.lines[i]\n    var span = getMarkedSpanFor(line.markedSpans, this$1)\n    if (cm && !this$1.collapsed) { regLineChange(cm, lineNo(line), \"text\") }\n    else if (cm) {\n      if (span.to != null) { max = lineNo(line) }\n      if (span.from != null) { min = lineNo(line) }\n    }\n    line.markedSpans = removeMarkedSpan(line.markedSpans, span)\n    if (span.from == null && this$1.collapsed && !lineIsHidden(this$1.doc, line) && cm)\n      { updateLineHeight(line, textHeight(cm.display)) }\n  }\n  if (cm && this.collapsed && !cm.options.lineWrapping) { for (var i$1 = 0; i$1 < this.lines.length; ++i$1) {\n    var visual = visualLine(this$1.lines[i$1]), len = lineLength(visual)\n    if (len > cm.display.maxLineLength) {\n      cm.display.maxLine = visual\n      cm.display.maxLineLength = len\n      cm.display.maxLineChanged = true\n    }\n  } }\n\n  if (min != null && cm && this.collapsed) { regChange(cm, min, max + 1) }\n  this.lines.length = 0\n  this.explicitlyCleared = true\n  if (this.atomic && this.doc.cantEdit) {\n    this.doc.cantEdit = false\n    if (cm) { reCheckSelection(cm.doc) }\n  }\n  if (cm) { signalLater(cm, \"markerCleared\", cm, this, min, max) }\n  if (withOp) { endOperation(cm) }\n  if (this.parent) { this.parent.clear() }\n};\n\n// Find the position of the marker in the document. Returns a {from,\n// to} object by default. Side can be passed to get a specific side\n// -- 0 (both), -1 (left), or 1 (right). When lineObj is true, the\n// Pos objects returned contain a line object, rather than a line\n// number (used to prevent looking up the same line twice).\nTextMarker.prototype.find = function (side, lineObj) {\n    var this$1 = this;\n\n  if (side == null && this.type == \"bookmark\") { side = 1 }\n  var from, to\n  for (var i = 0; i < this.lines.length; ++i) {\n    var line = this$1.lines[i]\n    var span = getMarkedSpanFor(line.markedSpans, this$1)\n    if (span.from != null) {\n      from = Pos(lineObj ? line : lineNo(line), span.from)\n      if (side == -1) { return from }\n    }\n    if (span.to != null) {\n      to = Pos(lineObj ? line : lineNo(line), span.to)\n      if (side == 1) { return to }\n    }\n  }\n  return from && {from: from, to: to}\n};\n\n// Signals that the marker's widget changed, and surrounding layout\n// should be recomputed.\nTextMarker.prototype.changed = function () {\n    var this$1 = this;\n\n  var pos = this.find(-1, true), widget = this, cm = this.doc.cm\n  if (!pos || !cm) { return }\n  runInOp(cm, function () {\n    var line = pos.line, lineN = lineNo(pos.line)\n    var view = findViewForLine(cm, lineN)\n    if (view) {\n      clearLineMeasurementCacheFor(view)\n      cm.curOp.selectionChanged = cm.curOp.forceUpdate = true\n    }\n    cm.curOp.updateMaxLine = true\n    if (!lineIsHidden(widget.doc, line) && widget.height != null) {\n      var oldHeight = widget.height\n      widget.height = null\n      var dHeight = widgetHeight(widget) - oldHeight\n      if (dHeight)\n        { updateLineHeight(line, line.height + dHeight) }\n    }\n    signalLater(cm, \"markerChanged\", cm, this$1)\n  })\n};\n\nTextMarker.prototype.attachLine = function (line) {\n  if (!this.lines.length && this.doc.cm) {\n    var op = this.doc.cm.curOp\n    if (!op.maybeHiddenMarkers || indexOf(op.maybeHiddenMarkers, this) == -1)\n      { (op.maybeUnhiddenMarkers || (op.maybeUnhiddenMarkers = [])).push(this) }\n  }\n  this.lines.push(line)\n};\n\nTextMarker.prototype.detachLine = function (line) {\n  this.lines.splice(indexOf(this.lines, line), 1)\n  if (!this.lines.length && this.doc.cm) {\n    var op = this.doc.cm.curOp\n    ;(op.maybeHiddenMarkers || (op.maybeHiddenMarkers = [])).push(this)\n  }\n};\neventMixin(TextMarker)\n\n// Create a marker, wire it up to the right lines, and\nfunction markText(doc, from, to, options, type) {\n  // Shared markers (across linked documents) are handled separately\n  // (markTextShared will call out to this again, once per\n  // document).\n  if (options && options.shared) { return markTextShared(doc, from, to, options, type) }\n  // Ensure we are in an operation.\n  if (doc.cm && !doc.cm.curOp) { return operation(doc.cm, markText)(doc, from, to, options, type) }\n\n  var marker = new TextMarker(doc, type), diff = cmp(from, to)\n  if (options) { copyObj(options, marker, false) }\n  // Don't connect empty markers unless clearWhenEmpty is false\n  if (diff > 0 || diff == 0 && marker.clearWhenEmpty !== false)\n    { return marker }\n  if (marker.replacedWith) {\n    // Showing up as a widget implies collapsed (widget replaces text)\n    marker.collapsed = true\n    marker.widgetNode = elt(\"span\", [marker.replacedWith], \"CodeMirror-widget\")\n    marker.widgetNode.setAttribute(\"role\", \"presentation\") // hide from accessibility tree\n    if (!options.handleMouseEvents) { marker.widgetNode.setAttribute(\"cm-ignore-events\", \"true\") }\n    if (options.insertLeft) { marker.widgetNode.insertLeft = true }\n  }\n  if (marker.collapsed) {\n    if (conflictingCollapsedRange(doc, from.line, from, to, marker) ||\n        from.line != to.line && conflictingCollapsedRange(doc, to.line, from, to, marker))\n      { throw new Error(\"Inserting collapsed marker partially overlapping an existing one\") }\n    seeCollapsedSpans()\n  }\n\n  if (marker.addToHistory)\n    { addChangeToHistory(doc, {from: from, to: to, origin: \"markText\"}, doc.sel, NaN) }\n\n  var curLine = from.line, cm = doc.cm, updateMaxLine\n  doc.iter(curLine, to.line + 1, function (line) {\n    if (cm && marker.collapsed && !cm.options.lineWrapping && visualLine(line) == cm.display.maxLine)\n      { updateMaxLine = true }\n    if (marker.collapsed && curLine != from.line) { updateLineHeight(line, 0) }\n    addMarkedSpan(line, new MarkedSpan(marker,\n                                       curLine == from.line ? from.ch : null,\n                                       curLine == to.line ? to.ch : null))\n    ++curLine\n  })\n  // lineIsHidden depends on the presence of the spans, so needs a second pass\n  if (marker.collapsed) { doc.iter(from.line, to.line + 1, function (line) {\n    if (lineIsHidden(doc, line)) { updateLineHeight(line, 0) }\n  }) }\n\n  if (marker.clearOnEnter) { on(marker, \"beforeCursorEnter\", function () { return marker.clear(); }) }\n\n  if (marker.readOnly) {\n    seeReadOnlySpans()\n    if (doc.history.done.length || doc.history.undone.length)\n      { doc.clearHistory() }\n  }\n  if (marker.collapsed) {\n    marker.id = ++nextMarkerId\n    marker.atomic = true\n  }\n  if (cm) {\n    // Sync editor state\n    if (updateMaxLine) { cm.curOp.updateMaxLine = true }\n    if (marker.collapsed)\n      { regChange(cm, from.line, to.line + 1) }\n    else if (marker.className || marker.title || marker.startStyle || marker.endStyle || marker.css)\n      { for (var i = from.line; i <= to.line; i++) { regLineChange(cm, i, \"text\") } }\n    if (marker.atomic) { reCheckSelection(cm.doc) }\n    signalLater(cm, \"markerAdded\", cm, marker)\n  }\n  return marker\n}\n\n// SHARED TEXTMARKERS\n\n// A shared marker spans multiple linked documents. It is\n// implemented as a meta-marker-object controlling multiple normal\n// markers.\nvar SharedTextMarker = function(markers, primary) {\n  var this$1 = this;\n\n  this.markers = markers\n  this.primary = primary\n  for (var i = 0; i < markers.length; ++i)\n    { markers[i].parent = this$1 }\n};\n\nSharedTextMarker.prototype.clear = function () {\n    var this$1 = this;\n\n  if (this.explicitlyCleared) { return }\n  this.explicitlyCleared = true\n  for (var i = 0; i < this.markers.length; ++i)\n    { this$1.markers[i].clear() }\n  signalLater(this, \"clear\")\n};\n\nSharedTextMarker.prototype.find = function (side, lineObj) {\n  return this.primary.find(side, lineObj)\n};\neventMixin(SharedTextMarker)\n\nfunction markTextShared(doc, from, to, options, type) {\n  options = copyObj(options)\n  options.shared = false\n  var markers = [markText(doc, from, to, options, type)], primary = markers[0]\n  var widget = options.widgetNode\n  linkedDocs(doc, function (doc) {\n    if (widget) { options.widgetNode = widget.cloneNode(true) }\n    markers.push(markText(doc, clipPos(doc, from), clipPos(doc, to), options, type))\n    for (var i = 0; i < doc.linked.length; ++i)\n      { if (doc.linked[i].isParent) { return } }\n    primary = lst(markers)\n  })\n  return new SharedTextMarker(markers, primary)\n}\n\nfunction findSharedMarkers(doc) {\n  return doc.findMarks(Pos(doc.first, 0), doc.clipPos(Pos(doc.lastLine())), function (m) { return m.parent; })\n}\n\nfunction copySharedMarkers(doc, markers) {\n  for (var i = 0; i < markers.length; i++) {\n    var marker = markers[i], pos = marker.find()\n    var mFrom = doc.clipPos(pos.from), mTo = doc.clipPos(pos.to)\n    if (cmp(mFrom, mTo)) {\n      var subMark = markText(doc, mFrom, mTo, marker.primary, marker.primary.type)\n      marker.markers.push(subMark)\n      subMark.parent = marker\n    }\n  }\n}\n\nfunction detachSharedMarkers(markers) {\n  var loop = function ( i ) {\n    var marker = markers[i], linked = [marker.primary.doc]\n    linkedDocs(marker.primary.doc, function (d) { return linked.push(d); })\n    for (var j = 0; j < marker.markers.length; j++) {\n      var subMarker = marker.markers[j]\n      if (indexOf(linked, subMarker.doc) == -1) {\n        subMarker.parent = null\n        marker.markers.splice(j--, 1)\n      }\n    }\n  };\n\n  for (var i = 0; i < markers.length; i++) loop( i );\n}\n\nvar nextDocId = 0\nvar Doc = function(text, mode, firstLine, lineSep) {\n  if (!(this instanceof Doc)) { return new Doc(text, mode, firstLine, lineSep) }\n  if (firstLine == null) { firstLine = 0 }\n\n  BranchChunk.call(this, [new LeafChunk([new Line(\"\", null)])])\n  this.first = firstLine\n  this.scrollTop = this.scrollLeft = 0\n  this.cantEdit = false\n  this.cleanGeneration = 1\n  this.frontier = firstLine\n  var start = Pos(firstLine, 0)\n  this.sel = simpleSelection(start)\n  this.history = new History(null)\n  this.id = ++nextDocId\n  this.modeOption = mode\n  this.lineSep = lineSep\n  this.extend = false\n\n  if (typeof text == \"string\") { text = this.splitLines(text) }\n  updateDoc(this, {from: start, to: start, text: text})\n  setSelection(this, simpleSelection(start), sel_dontScroll)\n}\n\nDoc.prototype = createObj(BranchChunk.prototype, {\n  constructor: Doc,\n  // Iterate over the document. Supports two forms -- with only one\n  // argument, it calls that for each line in the document. With\n  // three, it iterates over the range given by the first two (with\n  // the second being non-inclusive).\n  iter: function(from, to, op) {\n    if (op) { this.iterN(from - this.first, to - from, op) }\n    else { this.iterN(this.first, this.first + this.size, from) }\n  },\n\n  // Non-public interface for adding and removing lines.\n  insert: function(at, lines) {\n    var height = 0\n    for (var i = 0; i < lines.length; ++i) { height += lines[i].height }\n    this.insertInner(at - this.first, lines, height)\n  },\n  remove: function(at, n) { this.removeInner(at - this.first, n) },\n\n  // From here, the methods are part of the public interface. Most\n  // are also available from CodeMirror (editor) instances.\n\n  getValue: function(lineSep) {\n    var lines = getLines(this, this.first, this.first + this.size)\n    if (lineSep === false) { return lines }\n    return lines.join(lineSep || this.lineSeparator())\n  },\n  setValue: docMethodOp(function(code) {\n    var top = Pos(this.first, 0), last = this.first + this.size - 1\n    makeChange(this, {from: top, to: Pos(last, getLine(this, last).text.length),\n                      text: this.splitLines(code), origin: \"setValue\", full: true}, true)\n    setSelection(this, simpleSelection(top))\n  }),\n  replaceRange: function(code, from, to, origin) {\n    from = clipPos(this, from)\n    to = to ? clipPos(this, to) : from\n    replaceRange(this, code, from, to, origin)\n  },\n  getRange: function(from, to, lineSep) {\n    var lines = getBetween(this, clipPos(this, from), clipPos(this, to))\n    if (lineSep === false) { return lines }\n    return lines.join(lineSep || this.lineSeparator())\n  },\n\n  getLine: function(line) {var l = this.getLineHandle(line); return l && l.text},\n\n  getLineHandle: function(line) {if (isLine(this, line)) { return getLine(this, line) }},\n  getLineNumber: function(line) {return lineNo(line)},\n\n  getLineHandleVisualStart: function(line) {\n    if (typeof line == \"number\") { line = getLine(this, line) }\n    return visualLine(line)\n  },\n\n  lineCount: function() {return this.size},\n  firstLine: function() {return this.first},\n  lastLine: function() {return this.first + this.size - 1},\n\n  clipPos: function(pos) {return clipPos(this, pos)},\n\n  getCursor: function(start) {\n    var range = this.sel.primary(), pos\n    if (start == null || start == \"head\") { pos = range.head }\n    else if (start == \"anchor\") { pos = range.anchor }\n    else if (start == \"end\" || start == \"to\" || start === false) { pos = range.to() }\n    else { pos = range.from() }\n    return pos\n  },\n  listSelections: function() { return this.sel.ranges },\n  somethingSelected: function() {return this.sel.somethingSelected()},\n\n  setCursor: docMethodOp(function(line, ch, options) {\n    setSimpleSelection(this, clipPos(this, typeof line == \"number\" ? Pos(line, ch || 0) : line), null, options)\n  }),\n  setSelection: docMethodOp(function(anchor, head, options) {\n    setSimpleSelection(this, clipPos(this, anchor), clipPos(this, head || anchor), options)\n  }),\n  extendSelection: docMethodOp(function(head, other, options) {\n    extendSelection(this, clipPos(this, head), other && clipPos(this, other), options)\n  }),\n  extendSelections: docMethodOp(function(heads, options) {\n    extendSelections(this, clipPosArray(this, heads), options)\n  }),\n  extendSelectionsBy: docMethodOp(function(f, options) {\n    var heads = map(this.sel.ranges, f)\n    extendSelections(this, clipPosArray(this, heads), options)\n  }),\n  setSelections: docMethodOp(function(ranges, primary, options) {\n    var this$1 = this;\n\n    if (!ranges.length) { return }\n    var out = []\n    for (var i = 0; i < ranges.length; i++)\n      { out[i] = new Range(clipPos(this$1, ranges[i].anchor),\n                         clipPos(this$1, ranges[i].head)) }\n    if (primary == null) { primary = Math.min(ranges.length - 1, this.sel.primIndex) }\n    setSelection(this, normalizeSelection(out, primary), options)\n  }),\n  addSelection: docMethodOp(function(anchor, head, options) {\n    var ranges = this.sel.ranges.slice(0)\n    ranges.push(new Range(clipPos(this, anchor), clipPos(this, head || anchor)))\n    setSelection(this, normalizeSelection(ranges, ranges.length - 1), options)\n  }),\n\n  getSelection: function(lineSep) {\n    var this$1 = this;\n\n    var ranges = this.sel.ranges, lines\n    for (var i = 0; i < ranges.length; i++) {\n      var sel = getBetween(this$1, ranges[i].from(), ranges[i].to())\n      lines = lines ? lines.concat(sel) : sel\n    }\n    if (lineSep === false) { return lines }\n    else { return lines.join(lineSep || this.lineSeparator()) }\n  },\n  getSelections: function(lineSep) {\n    var this$1 = this;\n\n    var parts = [], ranges = this.sel.ranges\n    for (var i = 0; i < ranges.length; i++) {\n      var sel = getBetween(this$1, ranges[i].from(), ranges[i].to())\n      if (lineSep !== false) { sel = sel.join(lineSep || this$1.lineSeparator()) }\n      parts[i] = sel\n    }\n    return parts\n  },\n  replaceSelection: function(code, collapse, origin) {\n    var dup = []\n    for (var i = 0; i < this.sel.ranges.length; i++)\n      { dup[i] = code }\n    this.replaceSelections(dup, collapse, origin || \"+input\")\n  },\n  replaceSelections: docMethodOp(function(code, collapse, origin) {\n    var this$1 = this;\n\n    var changes = [], sel = this.sel\n    for (var i = 0; i < sel.ranges.length; i++) {\n      var range = sel.ranges[i]\n      changes[i] = {from: range.from(), to: range.to(), text: this$1.splitLines(code[i]), origin: origin}\n    }\n    var newSel = collapse && collapse != \"end\" && computeReplacedSel(this, changes, collapse)\n    for (var i$1 = changes.length - 1; i$1 >= 0; i$1--)\n      { makeChange(this$1, changes[i$1]) }\n    if (newSel) { setSelectionReplaceHistory(this, newSel) }\n    else if (this.cm) { ensureCursorVisible(this.cm) }\n  }),\n  undo: docMethodOp(function() {makeChangeFromHistory(this, \"undo\")}),\n  redo: docMethodOp(function() {makeChangeFromHistory(this, \"redo\")}),\n  undoSelection: docMethodOp(function() {makeChangeFromHistory(this, \"undo\", true)}),\n  redoSelection: docMethodOp(function() {makeChangeFromHistory(this, \"redo\", true)}),\n\n  setExtending: function(val) {this.extend = val},\n  getExtending: function() {return this.extend},\n\n  historySize: function() {\n    var hist = this.history, done = 0, undone = 0\n    for (var i = 0; i < hist.done.length; i++) { if (!hist.done[i].ranges) { ++done } }\n    for (var i$1 = 0; i$1 < hist.undone.length; i$1++) { if (!hist.undone[i$1].ranges) { ++undone } }\n    return {undo: done, redo: undone}\n  },\n  clearHistory: function() {this.history = new History(this.history.maxGeneration)},\n\n  markClean: function() {\n    this.cleanGeneration = this.changeGeneration(true)\n  },\n  changeGeneration: function(forceSplit) {\n    if (forceSplit)\n      { this.history.lastOp = this.history.lastSelOp = this.history.lastOrigin = null }\n    return this.history.generation\n  },\n  isClean: function (gen) {\n    return this.history.generation == (gen || this.cleanGeneration)\n  },\n\n  getHistory: function() {\n    return {done: copyHistoryArray(this.history.done),\n            undone: copyHistoryArray(this.history.undone)}\n  },\n  setHistory: function(histData) {\n    var hist = this.history = new History(this.history.maxGeneration)\n    hist.done = copyHistoryArray(histData.done.slice(0), null, true)\n    hist.undone = copyHistoryArray(histData.undone.slice(0), null, true)\n  },\n\n  setGutterMarker: docMethodOp(function(line, gutterID, value) {\n    return changeLine(this, line, \"gutter\", function (line) {\n      var markers = line.gutterMarkers || (line.gutterMarkers = {})\n      markers[gutterID] = value\n      if (!value && isEmpty(markers)) { line.gutterMarkers = null }\n      return true\n    })\n  }),\n\n  clearGutter: docMethodOp(function(gutterID) {\n    var this$1 = this;\n\n    this.iter(function (line) {\n      if (line.gutterMarkers && line.gutterMarkers[gutterID]) {\n        changeLine(this$1, line, \"gutter\", function () {\n          line.gutterMarkers[gutterID] = null\n          if (isEmpty(line.gutterMarkers)) { line.gutterMarkers = null }\n          return true\n        })\n      }\n    })\n  }),\n\n  lineInfo: function(line) {\n    var n\n    if (typeof line == \"number\") {\n      if (!isLine(this, line)) { return null }\n      n = line\n      line = getLine(this, line)\n      if (!line) { return null }\n    } else {\n      n = lineNo(line)\n      if (n == null) { return null }\n    }\n    return {line: n, handle: line, text: line.text, gutterMarkers: line.gutterMarkers,\n            textClass: line.textClass, bgClass: line.bgClass, wrapClass: line.wrapClass,\n            widgets: line.widgets}\n  },\n\n  addLineClass: docMethodOp(function(handle, where, cls) {\n    return changeLine(this, handle, where == \"gutter\" ? \"gutter\" : \"class\", function (line) {\n      var prop = where == \"text\" ? \"textClass\"\n               : where == \"background\" ? \"bgClass\"\n               : where == \"gutter\" ? \"gutterClass\" : \"wrapClass\"\n      if (!line[prop]) { line[prop] = cls }\n      else if (classTest(cls).test(line[prop])) { return false }\n      else { line[prop] += \" \" + cls }\n      return true\n    })\n  }),\n  removeLineClass: docMethodOp(function(handle, where, cls) {\n    return changeLine(this, handle, where == \"gutter\" ? \"gutter\" : \"class\", function (line) {\n      var prop = where == \"text\" ? \"textClass\"\n               : where == \"background\" ? \"bgClass\"\n               : where == \"gutter\" ? \"gutterClass\" : \"wrapClass\"\n      var cur = line[prop]\n      if (!cur) { return false }\n      else if (cls == null) { line[prop] = null }\n      else {\n        var found = cur.match(classTest(cls))\n        if (!found) { return false }\n        var end = found.index + found[0].length\n        line[prop] = cur.slice(0, found.index) + (!found.index || end == cur.length ? \"\" : \" \") + cur.slice(end) || null\n      }\n      return true\n    })\n  }),\n\n  addLineWidget: docMethodOp(function(handle, node, options) {\n    return addLineWidget(this, handle, node, options)\n  }),\n  removeLineWidget: function(widget) { widget.clear() },\n\n  markText: function(from, to, options) {\n    return markText(this, clipPos(this, from), clipPos(this, to), options, options && options.type || \"range\")\n  },\n  setBookmark: function(pos, options) {\n    var realOpts = {replacedWith: options && (options.nodeType == null ? options.widget : options),\n                    insertLeft: options && options.insertLeft,\n                    clearWhenEmpty: false, shared: options && options.shared,\n                    handleMouseEvents: options && options.handleMouseEvents}\n    pos = clipPos(this, pos)\n    return markText(this, pos, pos, realOpts, \"bookmark\")\n  },\n  findMarksAt: function(pos) {\n    pos = clipPos(this, pos)\n    var markers = [], spans = getLine(this, pos.line).markedSpans\n    if (spans) { for (var i = 0; i < spans.length; ++i) {\n      var span = spans[i]\n      if ((span.from == null || span.from <= pos.ch) &&\n          (span.to == null || span.to >= pos.ch))\n        { markers.push(span.marker.parent || span.marker) }\n    } }\n    return markers\n  },\n  findMarks: function(from, to, filter) {\n    from = clipPos(this, from); to = clipPos(this, to)\n    var found = [], lineNo = from.line\n    this.iter(from.line, to.line + 1, function (line) {\n      var spans = line.markedSpans\n      if (spans) { for (var i = 0; i < spans.length; i++) {\n        var span = spans[i]\n        if (!(span.to != null && lineNo == from.line && from.ch >= span.to ||\n              span.from == null && lineNo != from.line ||\n              span.from != null && lineNo == to.line && span.from >= to.ch) &&\n            (!filter || filter(span.marker)))\n          { found.push(span.marker.parent || span.marker) }\n      } }\n      ++lineNo\n    })\n    return found\n  },\n  getAllMarks: function() {\n    var markers = []\n    this.iter(function (line) {\n      var sps = line.markedSpans\n      if (sps) { for (var i = 0; i < sps.length; ++i)\n        { if (sps[i].from != null) { markers.push(sps[i].marker) } } }\n    })\n    return markers\n  },\n\n  posFromIndex: function(off) {\n    var ch, lineNo = this.first, sepSize = this.lineSeparator().length\n    this.iter(function (line) {\n      var sz = line.text.length + sepSize\n      if (sz > off) { ch = off; return true }\n      off -= sz\n      ++lineNo\n    })\n    return clipPos(this, Pos(lineNo, ch))\n  },\n  indexFromPos: function (coords) {\n    coords = clipPos(this, coords)\n    var index = coords.ch\n    if (coords.line < this.first || coords.ch < 0) { return 0 }\n    var sepSize = this.lineSeparator().length\n    this.iter(this.first, coords.line, function (line) { // iter aborts when callback returns a truthy value\n      index += line.text.length + sepSize\n    })\n    return index\n  },\n\n  copy: function(copyHistory) {\n    var doc = new Doc(getLines(this, this.first, this.first + this.size),\n                      this.modeOption, this.first, this.lineSep)\n    doc.scrollTop = this.scrollTop; doc.scrollLeft = this.scrollLeft\n    doc.sel = this.sel\n    doc.extend = false\n    if (copyHistory) {\n      doc.history.undoDepth = this.history.undoDepth\n      doc.setHistory(this.getHistory())\n    }\n    return doc\n  },\n\n  linkedDoc: function(options) {\n    if (!options) { options = {} }\n    var from = this.first, to = this.first + this.size\n    if (options.from != null && options.from > from) { from = options.from }\n    if (options.to != null && options.to < to) { to = options.to }\n    var copy = new Doc(getLines(this, from, to), options.mode || this.modeOption, from, this.lineSep)\n    if (options.sharedHist) { copy.history = this.history\n    ; }(this.linked || (this.linked = [])).push({doc: copy, sharedHist: options.sharedHist})\n    copy.linked = [{doc: this, isParent: true, sharedHist: options.sharedHist}]\n    copySharedMarkers(copy, findSharedMarkers(this))\n    return copy\n  },\n  unlinkDoc: function(other) {\n    var this$1 = this;\n\n    if (other instanceof CodeMirror) { other = other.doc }\n    if (this.linked) { for (var i = 0; i < this.linked.length; ++i) {\n      var link = this$1.linked[i]\n      if (link.doc != other) { continue }\n      this$1.linked.splice(i, 1)\n      other.unlinkDoc(this$1)\n      detachSharedMarkers(findSharedMarkers(this$1))\n      break\n    } }\n    // If the histories were shared, split them again\n    if (other.history == this.history) {\n      var splitIds = [other.id]\n      linkedDocs(other, function (doc) { return splitIds.push(doc.id); }, true)\n      other.history = new History(null)\n      other.history.done = copyHistoryArray(this.history.done, splitIds)\n      other.history.undone = copyHistoryArray(this.history.undone, splitIds)\n    }\n  },\n  iterLinkedDocs: function(f) {linkedDocs(this, f)},\n\n  getMode: function() {return this.mode},\n  getEditor: function() {return this.cm},\n\n  splitLines: function(str) {\n    if (this.lineSep) { return str.split(this.lineSep) }\n    return splitLinesAuto(str)\n  },\n  lineSeparator: function() { return this.lineSep || \"\\n\" }\n})\n\n// Public alias.\nDoc.prototype.eachLine = Doc.prototype.iter\n\n// Kludge to work around strange IE behavior where it'll sometimes\n// re-fire a series of drag-related events right after the drop (#1551)\nvar lastDrop = 0\n\nfunction onDrop(e) {\n  var cm = this\n  clearDragCursor(cm)\n  if (signalDOMEvent(cm, e) || eventInWidget(cm.display, e))\n    { return }\n  e_preventDefault(e)\n  if (ie) { lastDrop = +new Date }\n  var pos = posFromMouse(cm, e, true), files = e.dataTransfer.files\n  if (!pos || cm.isReadOnly()) { return }\n  // Might be a file drop, in which case we simply extract the text\n  // and insert it.\n  if (files && files.length && window.FileReader && window.File) {\n    var n = files.length, text = Array(n), read = 0\n    var loadFile = function (file, i) {\n      if (cm.options.allowDropFileTypes &&\n          indexOf(cm.options.allowDropFileTypes, file.type) == -1)\n        { return }\n\n      var reader = new FileReader\n      reader.onload = operation(cm, function () {\n        var content = reader.result\n        if (/[\\x00-\\x08\\x0e-\\x1f]{2}/.test(content)) { content = \"\" }\n        text[i] = content\n        if (++read == n) {\n          pos = clipPos(cm.doc, pos)\n          var change = {from: pos, to: pos,\n                        text: cm.doc.splitLines(text.join(cm.doc.lineSeparator())),\n                        origin: \"paste\"}\n          makeChange(cm.doc, change)\n          setSelectionReplaceHistory(cm.doc, simpleSelection(pos, changeEnd(change)))\n        }\n      })\n      reader.readAsText(file)\n    }\n    for (var i = 0; i < n; ++i) { loadFile(files[i], i) }\n  } else { // Normal drop\n    // Don't do a replace if the drop happened inside of the selected text.\n    if (cm.state.draggingText && cm.doc.sel.contains(pos) > -1) {\n      cm.state.draggingText(e)\n      // Ensure the editor is re-focused\n      setTimeout(function () { return cm.display.input.focus(); }, 20)\n      return\n    }\n    try {\n      var text$1 = e.dataTransfer.getData(\"Text\")\n      if (text$1) {\n        var selected\n        if (cm.state.draggingText && !cm.state.draggingText.copy)\n          { selected = cm.listSelections() }\n        setSelectionNoUndo(cm.doc, simpleSelection(pos, pos))\n        if (selected) { for (var i$1 = 0; i$1 < selected.length; ++i$1)\n          { replaceRange(cm.doc, \"\", selected[i$1].anchor, selected[i$1].head, \"drag\") } }\n        cm.replaceSelection(text$1, \"around\", \"paste\")\n        cm.display.input.focus()\n      }\n    }\n    catch(e){}\n  }\n}\n\nfunction onDragStart(cm, e) {\n  if (ie && (!cm.state.draggingText || +new Date - lastDrop < 100)) { e_stop(e); return }\n  if (signalDOMEvent(cm, e) || eventInWidget(cm.display, e)) { return }\n\n  e.dataTransfer.setData(\"Text\", cm.getSelection())\n  e.dataTransfer.effectAllowed = \"copyMove\"\n\n  // Use dummy image instead of default browsers image.\n  // Recent Safari (~6.0.2) have a tendency to segfault when this happens, so we don't do it there.\n  if (e.dataTransfer.setDragImage && !safari) {\n    var img = elt(\"img\", null, null, \"position: fixed; left: 0; top: 0;\")\n    img.src = \"data:image/gif;base64,R0lGODlhAQABAAAAACH5BAEKAAEALAAAAAABAAEAAAICTAEAOw==\"\n    if (presto) {\n      img.width = img.height = 1\n      cm.display.wrapper.appendChild(img)\n      // Force a relayout, or Opera won't use our image for some obscure reason\n      img._top = img.offsetTop\n    }\n    e.dataTransfer.setDragImage(img, 0, 0)\n    if (presto) { img.parentNode.removeChild(img) }\n  }\n}\n\nfunction onDragOver(cm, e) {\n  var pos = posFromMouse(cm, e)\n  if (!pos) { return }\n  var frag = document.createDocumentFragment()\n  drawSelectionCursor(cm, pos, frag)\n  if (!cm.display.dragCursor) {\n    cm.display.dragCursor = elt(\"div\", null, \"CodeMirror-cursors CodeMirror-dragcursors\")\n    cm.display.lineSpace.insertBefore(cm.display.dragCursor, cm.display.cursorDiv)\n  }\n  removeChildrenAndAdd(cm.display.dragCursor, frag)\n}\n\nfunction clearDragCursor(cm) {\n  if (cm.display.dragCursor) {\n    cm.display.lineSpace.removeChild(cm.display.dragCursor)\n    cm.display.dragCursor = null\n  }\n}\n\n// These must be handled carefully, because naively registering a\n// handler for each editor will cause the editors to never be\n// garbage collected.\n\nfunction forEachCodeMirror(f) {\n  if (!document.body.getElementsByClassName) { return }\n  var byClass = document.body.getElementsByClassName(\"CodeMirror\")\n  for (var i = 0; i < byClass.length; i++) {\n    var cm = byClass[i].CodeMirror\n    if (cm) { f(cm) }\n  }\n}\n\nvar globalsRegistered = false\nfunction ensureGlobalHandlers() {\n  if (globalsRegistered) { return }\n  registerGlobalHandlers()\n  globalsRegistered = true\n}\nfunction registerGlobalHandlers() {\n  // When the window resizes, we need to refresh active editors.\n  var resizeTimer\n  on(window, \"resize\", function () {\n    if (resizeTimer == null) { resizeTimer = setTimeout(function () {\n      resizeTimer = null\n      forEachCodeMirror(onResize)\n    }, 100) }\n  })\n  // When the window loses focus, we want to show the editor as blurred\n  on(window, \"blur\", function () { return forEachCodeMirror(onBlur); })\n}\n// Called when the window resizes\nfunction onResize(cm) {\n  var d = cm.display\n  if (d.lastWrapHeight == d.wrapper.clientHeight && d.lastWrapWidth == d.wrapper.clientWidth)\n    { return }\n  // Might be a text scaling operation, clear size caches.\n  d.cachedCharWidth = d.cachedTextHeight = d.cachedPaddingH = null\n  d.scrollbarsClipped = false\n  cm.setSize()\n}\n\nvar keyNames = {\n  3: \"Enter\", 8: \"Backspace\", 9: \"Tab\", 13: \"Enter\", 16: \"Shift\", 17: \"Ctrl\", 18: \"Alt\",\n  19: \"Pause\", 20: \"CapsLock\", 27: \"Esc\", 32: \"Space\", 33: \"PageUp\", 34: \"PageDown\", 35: \"End\",\n  36: \"Home\", 37: \"Left\", 38: \"Up\", 39: \"Right\", 40: \"Down\", 44: \"PrintScrn\", 45: \"Insert\",\n  46: \"Delete\", 59: \";\", 61: \"=\", 91: \"Mod\", 92: \"Mod\", 93: \"Mod\",\n  106: \"*\", 107: \"=\", 109: \"-\", 110: \".\", 111: \"/\", 127: \"Delete\",\n  173: \"-\", 186: \";\", 187: \"=\", 188: \",\", 189: \"-\", 190: \".\", 191: \"/\", 192: \"`\", 219: \"[\", 220: \"\\\\\",\n  221: \"]\", 222: \"'\", 63232: \"Up\", 63233: \"Down\", 63234: \"Left\", 63235: \"Right\", 63272: \"Delete\",\n  63273: \"Home\", 63275: \"End\", 63276: \"PageUp\", 63277: \"PageDown\", 63302: \"Insert\"\n}\n\n// Number keys\nfor (var i = 0; i < 10; i++) { keyNames[i + 48] = keyNames[i + 96] = String(i) }\n// Alphabetic keys\nfor (var i$1 = 65; i$1 <= 90; i$1++) { keyNames[i$1] = String.fromCharCode(i$1) }\n// Function keys\nfor (var i$2 = 1; i$2 <= 12; i$2++) { keyNames[i$2 + 111] = keyNames[i$2 + 63235] = \"F\" + i$2 }\n\nvar keyMap = {}\n\nkeyMap.basic = {\n  \"Left\": \"goCharLeft\", \"Right\": \"goCharRight\", \"Up\": \"goLineUp\", \"Down\": \"goLineDown\",\n  \"End\": \"goLineEnd\", \"Home\": \"goLineStartSmart\", \"PageUp\": \"goPageUp\", \"PageDown\": \"goPageDown\",\n  \"Delete\": \"delCharAfter\", \"Backspace\": \"delCharBefore\", \"Shift-Backspace\": \"delCharBefore\",\n  \"Tab\": \"defaultTab\", \"Shift-Tab\": \"indentAuto\",\n  \"Enter\": \"newlineAndIndent\", \"Insert\": \"toggleOverwrite\",\n  \"Esc\": \"singleSelection\"\n}\n// Note that the save and find-related commands aren't defined by\n// default. User code or addons can define them. Unknown commands\n// are simply ignored.\nkeyMap.pcDefault = {\n  \"Ctrl-A\": \"selectAll\", \"Ctrl-D\": \"deleteLine\", \"Ctrl-Z\": \"undo\", \"Shift-Ctrl-Z\": \"redo\", \"Ctrl-Y\": \"redo\",\n  \"Ctrl-Home\": \"goDocStart\", \"Ctrl-End\": \"goDocEnd\", \"Ctrl-Up\": \"goLineUp\", \"Ctrl-Down\": \"goLineDown\",\n  \"Ctrl-Left\": \"goGroupLeft\", \"Ctrl-Right\": \"goGroupRight\", \"Alt-Left\": \"goLineStart\", \"Alt-Right\": \"goLineEnd\",\n  \"Ctrl-Backspace\": \"delGroupBefore\", \"Ctrl-Delete\": \"delGroupAfter\", \"Ctrl-S\": \"save\", \"Ctrl-F\": \"find\",\n  \"Ctrl-G\": \"findNext\", \"Shift-Ctrl-G\": \"findPrev\", \"Shift-Ctrl-F\": \"replace\", \"Shift-Ctrl-R\": \"replaceAll\",\n  \"Ctrl-[\": \"indentLess\", \"Ctrl-]\": \"indentMore\",\n  \"Ctrl-U\": \"undoSelection\", \"Shift-Ctrl-U\": \"redoSelection\", \"Alt-U\": \"redoSelection\",\n  fallthrough: \"basic\"\n}\n// Very basic readline/emacs-style bindings, which are standard on Mac.\nkeyMap.emacsy = {\n  \"Ctrl-F\": \"goCharRight\", \"Ctrl-B\": \"goCharLeft\", \"Ctrl-P\": \"goLineUp\", \"Ctrl-N\": \"goLineDown\",\n  \"Alt-F\": \"goWordRight\", \"Alt-B\": \"goWordLeft\", \"Ctrl-A\": \"goLineStart\", \"Ctrl-E\": \"goLineEnd\",\n  \"Ctrl-V\": \"goPageDown\", \"Shift-Ctrl-V\": \"goPageUp\", \"Ctrl-D\": \"delCharAfter\", \"Ctrl-H\": \"delCharBefore\",\n  \"Alt-D\": \"delWordAfter\", \"Alt-Backspace\": \"delWordBefore\", \"Ctrl-K\": \"killLine\", \"Ctrl-T\": \"transposeChars\",\n  \"Ctrl-O\": \"openLine\"\n}\nkeyMap.macDefault = {\n  \"Cmd-A\": \"selectAll\", \"Cmd-D\": \"deleteLine\", \"Cmd-Z\": \"undo\", \"Shift-Cmd-Z\": \"redo\", \"Cmd-Y\": \"redo\",\n  \"Cmd-Home\": \"goDocStart\", \"Cmd-Up\": \"goDocStart\", \"Cmd-End\": \"goDocEnd\", \"Cmd-Down\": \"goDocEnd\", \"Alt-Left\": \"goGroupLeft\",\n  \"Alt-Right\": \"goGroupRight\", \"Cmd-Left\": \"goLineLeft\", \"Cmd-Right\": \"goLineRight\", \"Alt-Backspace\": \"delGroupBefore\",\n  \"Ctrl-Alt-Backspace\": \"delGroupAfter\", \"Alt-Delete\": \"delGroupAfter\", \"Cmd-S\": \"save\", \"Cmd-F\": \"find\",\n  \"Cmd-G\": \"findNext\", \"Shift-Cmd-G\": \"findPrev\", \"Cmd-Alt-F\": \"replace\", \"Shift-Cmd-Alt-F\": \"replaceAll\",\n  \"Cmd-[\": \"indentLess\", \"Cmd-]\": \"indentMore\", \"Cmd-Backspace\": \"delWrappedLineLeft\", \"Cmd-Delete\": \"delWrappedLineRight\",\n  \"Cmd-U\": \"undoSelection\", \"Shift-Cmd-U\": \"redoSelection\", \"Ctrl-Up\": \"goDocStart\", \"Ctrl-Down\": \"goDocEnd\",\n  fallthrough: [\"basic\", \"emacsy\"]\n}\nkeyMap[\"default\"] = mac ? keyMap.macDefault : keyMap.pcDefault\n\n// KEYMAP DISPATCH\n\nfunction normalizeKeyName(name) {\n  var parts = name.split(/-(?!$)/)\n  name = parts[parts.length - 1]\n  var alt, ctrl, shift, cmd\n  for (var i = 0; i < parts.length - 1; i++) {\n    var mod = parts[i]\n    if (/^(cmd|meta|m)$/i.test(mod)) { cmd = true }\n    else if (/^a(lt)?$/i.test(mod)) { alt = true }\n    else if (/^(c|ctrl|control)$/i.test(mod)) { ctrl = true }\n    else if (/^s(hift)?$/i.test(mod)) { shift = true }\n    else { throw new Error(\"Unrecognized modifier name: \" + mod) }\n  }\n  if (alt) { name = \"Alt-\" + name }\n  if (ctrl) { name = \"Ctrl-\" + name }\n  if (cmd) { name = \"Cmd-\" + name }\n  if (shift) { name = \"Shift-\" + name }\n  return name\n}\n\n// This is a kludge to keep keymaps mostly working as raw objects\n// (backwards compatibility) while at the same time support features\n// like normalization and multi-stroke key bindings. It compiles a\n// new normalized keymap, and then updates the old object to reflect\n// this.\nfunction normalizeKeyMap(keymap) {\n  var copy = {}\n  for (var keyname in keymap) { if (keymap.hasOwnProperty(keyname)) {\n    var value = keymap[keyname]\n    if (/^(name|fallthrough|(de|at)tach)$/.test(keyname)) { continue }\n    if (value == \"...\") { delete keymap[keyname]; continue }\n\n    var keys = map(keyname.split(\" \"), normalizeKeyName)\n    for (var i = 0; i < keys.length; i++) {\n      var val = (void 0), name = (void 0)\n      if (i == keys.length - 1) {\n        name = keys.join(\" \")\n        val = value\n      } else {\n        name = keys.slice(0, i + 1).join(\" \")\n        val = \"...\"\n      }\n      var prev = copy[name]\n      if (!prev) { copy[name] = val }\n      else if (prev != val) { throw new Error(\"Inconsistent bindings for \" + name) }\n    }\n    delete keymap[keyname]\n  } }\n  for (var prop in copy) { keymap[prop] = copy[prop] }\n  return keymap\n}\n\nfunction lookupKey(key, map, handle, context) {\n  map = getKeyMap(map)\n  var found = map.call ? map.call(key, context) : map[key]\n  if (found === false) { return \"nothing\" }\n  if (found === \"...\") { return \"multi\" }\n  if (found != null && handle(found)) { return \"handled\" }\n\n  if (map.fallthrough) {\n    if (Object.prototype.toString.call(map.fallthrough) != \"[object Array]\")\n      { return lookupKey(key, map.fallthrough, handle, context) }\n    for (var i = 0; i < map.fallthrough.length; i++) {\n      var result = lookupKey(key, map.fallthrough[i], handle, context)\n      if (result) { return result }\n    }\n  }\n}\n\n// Modifier key presses don't count as 'real' key presses for the\n// purpose of keymap fallthrough.\nfunction isModifierKey(value) {\n  var name = typeof value == \"string\" ? value : keyNames[value.keyCode]\n  return name == \"Ctrl\" || name == \"Alt\" || name == \"Shift\" || name == \"Mod\"\n}\n\n// Look up the name of a key as indicated by an event object.\nfunction keyName(event, noShift) {\n  if (presto && event.keyCode == 34 && event[\"char\"]) { return false }\n  var base = keyNames[event.keyCode], name = base\n  if (name == null || event.altGraphKey) { return false }\n  if (event.altKey && base != \"Alt\") { name = \"Alt-\" + name }\n  if ((flipCtrlCmd ? event.metaKey : event.ctrlKey) && base != \"Ctrl\") { name = \"Ctrl-\" + name }\n  if ((flipCtrlCmd ? event.ctrlKey : event.metaKey) && base != \"Cmd\") { name = \"Cmd-\" + name }\n  if (!noShift && event.shiftKey && base != \"Shift\") { name = \"Shift-\" + name }\n  return name\n}\n\nfunction getKeyMap(val) {\n  return typeof val == \"string\" ? keyMap[val] : val\n}\n\n// Helper for deleting text near the selection(s), used to implement\n// backspace, delete, and similar functionality.\nfunction deleteNearSelection(cm, compute) {\n  var ranges = cm.doc.sel.ranges, kill = []\n  // Build up a set of ranges to kill first, merging overlapping\n  // ranges.\n  for (var i = 0; i < ranges.length; i++) {\n    var toKill = compute(ranges[i])\n    while (kill.length && cmp(toKill.from, lst(kill).to) <= 0) {\n      var replaced = kill.pop()\n      if (cmp(replaced.from, toKill.from) < 0) {\n        toKill.from = replaced.from\n        break\n      }\n    }\n    kill.push(toKill)\n  }\n  // Next, remove those actual ranges.\n  runInOp(cm, function () {\n    for (var i = kill.length - 1; i >= 0; i--)\n      { replaceRange(cm.doc, \"\", kill[i].from, kill[i].to, \"+delete\") }\n    ensureCursorVisible(cm)\n  })\n}\n\n// Commands are parameter-less actions that can be performed on an\n// editor, mostly used for keybindings.\nvar commands = {\n  selectAll: selectAll,\n  singleSelection: function (cm) { return cm.setSelection(cm.getCursor(\"anchor\"), cm.getCursor(\"head\"), sel_dontScroll); },\n  killLine: function (cm) { return deleteNearSelection(cm, function (range) {\n    if (range.empty()) {\n      var len = getLine(cm.doc, range.head.line).text.length\n      if (range.head.ch == len && range.head.line < cm.lastLine())\n        { return {from: range.head, to: Pos(range.head.line + 1, 0)} }\n      else\n        { return {from: range.head, to: Pos(range.head.line, len)} }\n    } else {\n      return {from: range.from(), to: range.to()}\n    }\n  }); },\n  deleteLine: function (cm) { return deleteNearSelection(cm, function (range) { return ({\n    from: Pos(range.from().line, 0),\n    to: clipPos(cm.doc, Pos(range.to().line + 1, 0))\n  }); }); },\n  delLineLeft: function (cm) { return deleteNearSelection(cm, function (range) { return ({\n    from: Pos(range.from().line, 0), to: range.from()\n  }); }); },\n  delWrappedLineLeft: function (cm) { return deleteNearSelection(cm, function (range) {\n    var top = cm.charCoords(range.head, \"div\").top + 5\n    var leftPos = cm.coordsChar({left: 0, top: top}, \"div\")\n    return {from: leftPos, to: range.from()}\n  }); },\n  delWrappedLineRight: function (cm) { return deleteNearSelection(cm, function (range) {\n    var top = cm.charCoords(range.head, \"div\").top + 5\n    var rightPos = cm.coordsChar({left: cm.display.lineDiv.offsetWidth + 100, top: top}, \"div\")\n    return {from: range.from(), to: rightPos }\n  }); },\n  undo: function (cm) { return cm.undo(); },\n  redo: function (cm) { return cm.redo(); },\n  undoSelection: function (cm) { return cm.undoSelection(); },\n  redoSelection: function (cm) { return cm.redoSelection(); },\n  goDocStart: function (cm) { return cm.extendSelection(Pos(cm.firstLine(), 0)); },\n  goDocEnd: function (cm) { return cm.extendSelection(Pos(cm.lastLine())); },\n  goLineStart: function (cm) { return cm.extendSelectionsBy(function (range) { return lineStart(cm, range.head.line); },\n    {origin: \"+move\", bias: 1}\n  ); },\n  goLineStartSmart: function (cm) { return cm.extendSelectionsBy(function (range) { return lineStartSmart(cm, range.head); },\n    {origin: \"+move\", bias: 1}\n  ); },\n  goLineEnd: function (cm) { return cm.extendSelectionsBy(function (range) { return lineEnd(cm, range.head.line); },\n    {origin: \"+move\", bias: -1}\n  ); },\n  goLineRight: function (cm) { return cm.extendSelectionsBy(function (range) {\n    var top = cm.charCoords(range.head, \"div\").top + 5\n    return cm.coordsChar({left: cm.display.lineDiv.offsetWidth + 100, top: top}, \"div\")\n  }, sel_move); },\n  goLineLeft: function (cm) { return cm.extendSelectionsBy(function (range) {\n    var top = cm.charCoords(range.head, \"div\").top + 5\n    return cm.coordsChar({left: 0, top: top}, \"div\")\n  }, sel_move); },\n  goLineLeftSmart: function (cm) { return cm.extendSelectionsBy(function (range) {\n    var top = cm.charCoords(range.head, \"div\").top + 5\n    var pos = cm.coordsChar({left: 0, top: top}, \"div\")\n    if (pos.ch < cm.getLine(pos.line).search(/\\S/)) { return lineStartSmart(cm, range.head) }\n    return pos\n  }, sel_move); },\n  goLineUp: function (cm) { return cm.moveV(-1, \"line\"); },\n  goLineDown: function (cm) { return cm.moveV(1, \"line\"); },\n  goPageUp: function (cm) { return cm.moveV(-1, \"page\"); },\n  goPageDown: function (cm) { return cm.moveV(1, \"page\"); },\n  goCharLeft: function (cm) { return cm.moveH(-1, \"char\"); },\n  goCharRight: function (cm) { return cm.moveH(1, \"char\"); },\n  goColumnLeft: function (cm) { return cm.moveH(-1, \"column\"); },\n  goColumnRight: function (cm) { return cm.moveH(1, \"column\"); },\n  goWordLeft: function (cm) { return cm.moveH(-1, \"word\"); },\n  goGroupRight: function (cm) { return cm.moveH(1, \"group\"); },\n  goGroupLeft: function (cm) { return cm.moveH(-1, \"group\"); },\n  goWordRight: function (cm) { return cm.moveH(1, \"word\"); },\n  delCharBefore: function (cm) { return cm.deleteH(-1, \"char\"); },\n  delCharAfter: function (cm) { return cm.deleteH(1, \"char\"); },\n  delWordBefore: function (cm) { return cm.deleteH(-1, \"word\"); },\n  delWordAfter: function (cm) { return cm.deleteH(1, \"word\"); },\n  delGroupBefore: function (cm) { return cm.deleteH(-1, \"group\"); },\n  delGroupAfter: function (cm) { return cm.deleteH(1, \"group\"); },\n  indentAuto: function (cm) { return cm.indentSelection(\"smart\"); },\n  indentMore: function (cm) { return cm.indentSelection(\"add\"); },\n  indentLess: function (cm) { return cm.indentSelection(\"subtract\"); },\n  insertTab: function (cm) { return cm.replaceSelection(\"\\t\"); },\n  insertSoftTab: function (cm) {\n    var spaces = [], ranges = cm.listSelections(), tabSize = cm.options.tabSize\n    for (var i = 0; i < ranges.length; i++) {\n      var pos = ranges[i].from()\n      var col = countColumn(cm.getLine(pos.line), pos.ch, tabSize)\n      spaces.push(spaceStr(tabSize - col % tabSize))\n    }\n    cm.replaceSelections(spaces)\n  },\n  defaultTab: function (cm) {\n    if (cm.somethingSelected()) { cm.indentSelection(\"add\") }\n    else { cm.execCommand(\"insertTab\") }\n  },\n  // Swap the two chars left and right of each selection's head.\n  // Move cursor behind the two swapped characters afterwards.\n  //\n  // Doesn't consider line feeds a character.\n  // Doesn't scan more than one line above to find a character.\n  // Doesn't do anything on an empty line.\n  // Doesn't do anything with non-empty selections.\n  transposeChars: function (cm) { return runInOp(cm, function () {\n    var ranges = cm.listSelections(), newSel = []\n    for (var i = 0; i < ranges.length; i++) {\n      if (!ranges[i].empty()) { continue }\n      var cur = ranges[i].head, line = getLine(cm.doc, cur.line).text\n      if (line) {\n        if (cur.ch == line.length) { cur = new Pos(cur.line, cur.ch - 1) }\n        if (cur.ch > 0) {\n          cur = new Pos(cur.line, cur.ch + 1)\n          cm.replaceRange(line.charAt(cur.ch - 1) + line.charAt(cur.ch - 2),\n                          Pos(cur.line, cur.ch - 2), cur, \"+transpose\")\n        } else if (cur.line > cm.doc.first) {\n          var prev = getLine(cm.doc, cur.line - 1).text\n          if (prev) {\n            cur = new Pos(cur.line, 1)\n            cm.replaceRange(line.charAt(0) + cm.doc.lineSeparator() +\n                            prev.charAt(prev.length - 1),\n                            Pos(cur.line - 1, prev.length - 1), cur, \"+transpose\")\n          }\n        }\n      }\n      newSel.push(new Range(cur, cur))\n    }\n    cm.setSelections(newSel)\n  }); },\n  newlineAndIndent: function (cm) { return runInOp(cm, function () {\n    var sels = cm.listSelections()\n    for (var i = sels.length - 1; i >= 0; i--)\n      { cm.replaceRange(cm.doc.lineSeparator(), sels[i].anchor, sels[i].head, \"+input\") }\n    sels = cm.listSelections()\n    for (var i$1 = 0; i$1 < sels.length; i$1++)\n      { cm.indentLine(sels[i$1].from().line, null, true) }\n    ensureCursorVisible(cm)\n  }); },\n  openLine: function (cm) { return cm.replaceSelection(\"\\n\", \"start\"); },\n  toggleOverwrite: function (cm) { return cm.toggleOverwrite(); }\n}\n\n\nfunction lineStart(cm, lineN) {\n  var line = getLine(cm.doc, lineN)\n  var visual = visualLine(line)\n  if (visual != line) { lineN = lineNo(visual) }\n  return endOfLine(true, cm, visual, lineN, 1)\n}\nfunction lineEnd(cm, lineN) {\n  var line = getLine(cm.doc, lineN)\n  var visual = visualLineEnd(line)\n  if (visual != line) { lineN = lineNo(visual) }\n  return endOfLine(true, cm, line, lineN, -1)\n}\nfunction lineStartSmart(cm, pos) {\n  var start = lineStart(cm, pos.line)\n  var line = getLine(cm.doc, start.line)\n  var order = getOrder(line)\n  if (!order || order[0].level == 0) {\n    var firstNonWS = Math.max(0, line.text.search(/\\S/))\n    var inWS = pos.line == start.line && pos.ch <= firstNonWS && pos.ch\n    return Pos(start.line, inWS ? 0 : firstNonWS, start.sticky)\n  }\n  return start\n}\n\n// Run a handler that was bound to a key.\nfunction doHandleBinding(cm, bound, dropShift) {\n  if (typeof bound == \"string\") {\n    bound = commands[bound]\n    if (!bound) { return false }\n  }\n  // Ensure previous input has been read, so that the handler sees a\n  // consistent view of the document\n  cm.display.input.ensurePolled()\n  var prevShift = cm.display.shift, done = false\n  try {\n    if (cm.isReadOnly()) { cm.state.suppressEdits = true }\n    if (dropShift) { cm.display.shift = false }\n    done = bound(cm) != Pass\n  } finally {\n    cm.display.shift = prevShift\n    cm.state.suppressEdits = false\n  }\n  return done\n}\n\nfunction lookupKeyForEditor(cm, name, handle) {\n  for (var i = 0; i < cm.state.keyMaps.length; i++) {\n    var result = lookupKey(name, cm.state.keyMaps[i], handle, cm)\n    if (result) { return result }\n  }\n  return (cm.options.extraKeys && lookupKey(name, cm.options.extraKeys, handle, cm))\n    || lookupKey(name, cm.options.keyMap, handle, cm)\n}\n\nvar stopSeq = new Delayed\nfunction dispatchKey(cm, name, e, handle) {\n  var seq = cm.state.keySeq\n  if (seq) {\n    if (isModifierKey(name)) { return \"handled\" }\n    stopSeq.set(50, function () {\n      if (cm.state.keySeq == seq) {\n        cm.state.keySeq = null\n        cm.display.input.reset()\n      }\n    })\n    name = seq + \" \" + name\n  }\n  var result = lookupKeyForEditor(cm, name, handle)\n\n  if (result == \"multi\")\n    { cm.state.keySeq = name }\n  if (result == \"handled\")\n    { signalLater(cm, \"keyHandled\", cm, name, e) }\n\n  if (result == \"handled\" || result == \"multi\") {\n    e_preventDefault(e)\n    restartBlink(cm)\n  }\n\n  if (seq && !result && /\\'$/.test(name)) {\n    e_preventDefault(e)\n    return true\n  }\n  return !!result\n}\n\n// Handle a key from the keydown event.\nfunction handleKeyBinding(cm, e) {\n  var name = keyName(e, true)\n  if (!name) { return false }\n\n  if (e.shiftKey && !cm.state.keySeq) {\n    // First try to resolve full name (including 'Shift-'). Failing\n    // that, see if there is a cursor-motion command (starting with\n    // 'go') bound to the keyname without 'Shift-'.\n    return dispatchKey(cm, \"Shift-\" + name, e, function (b) { return doHandleBinding(cm, b, true); })\n        || dispatchKey(cm, name, e, function (b) {\n             if (typeof b == \"string\" ? /^go[A-Z]/.test(b) : b.motion)\n               { return doHandleBinding(cm, b) }\n           })\n  } else {\n    return dispatchKey(cm, name, e, function (b) { return doHandleBinding(cm, b); })\n  }\n}\n\n// Handle a key from the keypress event\nfunction handleCharBinding(cm, e, ch) {\n  return dispatchKey(cm, \"'\" + ch + \"'\", e, function (b) { return doHandleBinding(cm, b, true); })\n}\n\nvar lastStoppedKey = null\nfunction onKeyDown(e) {\n  var cm = this\n  cm.curOp.focus = activeElt()\n  if (signalDOMEvent(cm, e)) { return }\n  // IE does strange things with escape.\n  if (ie && ie_version < 11 && e.keyCode == 27) { e.returnValue = false }\n  var code = e.keyCode\n  cm.display.shift = code == 16 || e.shiftKey\n  var handled = handleKeyBinding(cm, e)\n  if (presto) {\n    lastStoppedKey = handled ? code : null\n    // Opera has no cut event... we try to at least catch the key combo\n    if (!handled && code == 88 && !hasCopyEvent && (mac ? e.metaKey : e.ctrlKey))\n      { cm.replaceSelection(\"\", null, \"cut\") }\n  }\n\n  // Turn mouse into crosshair when Alt is held on Mac.\n  if (code == 18 && !/\\bCodeMirror-crosshair\\b/.test(cm.display.lineDiv.className))\n    { showCrossHair(cm) }\n}\n\nfunction showCrossHair(cm) {\n  var lineDiv = cm.display.lineDiv\n  addClass(lineDiv, \"CodeMirror-crosshair\")\n\n  function up(e) {\n    if (e.keyCode == 18 || !e.altKey) {\n      rmClass(lineDiv, \"CodeMirror-crosshair\")\n      off(document, \"keyup\", up)\n      off(document, \"mouseover\", up)\n    }\n  }\n  on(document, \"keyup\", up)\n  on(document, \"mouseover\", up)\n}\n\nfunction onKeyUp(e) {\n  if (e.keyCode == 16) { this.doc.sel.shift = false }\n  signalDOMEvent(this, e)\n}\n\nfunction onKeyPress(e) {\n  var cm = this\n  if (eventInWidget(cm.display, e) || signalDOMEvent(cm, e) || e.ctrlKey && !e.altKey || mac && e.metaKey) { return }\n  var keyCode = e.keyCode, charCode = e.charCode\n  if (presto && keyCode == lastStoppedKey) {lastStoppedKey = null; e_preventDefault(e); return}\n  if ((presto && (!e.which || e.which < 10)) && handleKeyBinding(cm, e)) { return }\n  var ch = String.fromCharCode(charCode == null ? keyCode : charCode)\n  // Some browsers fire keypress events for backspace\n  if (ch == \"\\x08\") { return }\n  if (handleCharBinding(cm, e, ch)) { return }\n  cm.display.input.onKeyPress(e)\n}\n\n// A mouse down can be a single click, double click, triple click,\n// start of selection drag, start of text drag, new cursor\n// (ctrl-click), rectangle drag (alt-drag), or xwin\n// middle-click-paste. Or it might be a click on something we should\n// not interfere with, such as a scrollbar or widget.\nfunction onMouseDown(e) {\n  var cm = this, display = cm.display\n  if (signalDOMEvent(cm, e) || display.activeTouch && display.input.supportsTouch()) { return }\n  display.input.ensurePolled()\n  display.shift = e.shiftKey\n\n  if (eventInWidget(display, e)) {\n    if (!webkit) {\n      // Briefly turn off draggability, to allow widgets to do\n      // normal dragging things.\n      display.scroller.draggable = false\n      setTimeout(function () { return display.scroller.draggable = true; }, 100)\n    }\n    return\n  }\n  if (clickInGutter(cm, e)) { return }\n  var start = posFromMouse(cm, e)\n  window.focus()\n\n  switch (e_button(e)) {\n  case 1:\n    // #3261: make sure, that we're not starting a second selection\n    if (cm.state.selectingText)\n      { cm.state.selectingText(e) }\n    else if (start)\n      { leftButtonDown(cm, e, start) }\n    else if (e_target(e) == display.scroller)\n      { e_preventDefault(e) }\n    break\n  case 2:\n    if (webkit) { cm.state.lastMiddleDown = +new Date }\n    if (start) { extendSelection(cm.doc, start) }\n    setTimeout(function () { return display.input.focus(); }, 20)\n    e_preventDefault(e)\n    break\n  case 3:\n    if (captureRightClick) { onContextMenu(cm, e) }\n    else { delayBlurEvent(cm) }\n    break\n  }\n}\n\nvar lastClick;\nvar lastDoubleClick;\nfunction leftButtonDown(cm, e, start) {\n  if (ie) { setTimeout(bind(ensureFocus, cm), 0) }\n  else { cm.curOp.focus = activeElt() }\n\n  var now = +new Date, type\n  if (lastDoubleClick && lastDoubleClick.time > now - 400 && cmp(lastDoubleClick.pos, start) == 0) {\n    type = \"triple\"\n  } else if (lastClick && lastClick.time > now - 400 && cmp(lastClick.pos, start) == 0) {\n    type = \"double\"\n    lastDoubleClick = {time: now, pos: start}\n  } else {\n    type = \"single\"\n    lastClick = {time: now, pos: start}\n  }\n\n  var sel = cm.doc.sel, modifier = mac ? e.metaKey : e.ctrlKey, contained\n  if (cm.options.dragDrop && dragAndDrop && !cm.isReadOnly() &&\n      type == \"single\" && (contained = sel.contains(start)) > -1 &&\n      (cmp((contained = sel.ranges[contained]).from(), start) < 0 || start.xRel > 0) &&\n      (cmp(contained.to(), start) > 0 || start.xRel < 0))\n    { leftButtonStartDrag(cm, e, start, modifier) }\n  else\n    { leftButtonSelect(cm, e, start, type, modifier) }\n}\n\n// Start a text drag. When it ends, see if any dragging actually\n// happen, and treat as a click if it didn't.\nfunction leftButtonStartDrag(cm, e, start, modifier) {\n  var display = cm.display, startTime = +new Date\n  var dragEnd = operation(cm, function (e2) {\n    if (webkit) { display.scroller.draggable = false }\n    cm.state.draggingText = false\n    off(document, \"mouseup\", dragEnd)\n    off(display.scroller, \"drop\", dragEnd)\n    if (Math.abs(e.clientX - e2.clientX) + Math.abs(e.clientY - e2.clientY) < 10) {\n      e_preventDefault(e2)\n      if (!modifier && +new Date - 200 < startTime)\n        { extendSelection(cm.doc, start) }\n      // Work around unexplainable focus problem in IE9 (#2127) and Chrome (#3081)\n      if (webkit || ie && ie_version == 9)\n        { setTimeout(function () {document.body.focus(); display.input.focus()}, 20) }\n      else\n        { display.input.focus() }\n    }\n  })\n  // Let the drag handler handle this.\n  if (webkit) { display.scroller.draggable = true }\n  cm.state.draggingText = dragEnd\n  dragEnd.copy = mac ? e.altKey : e.ctrlKey\n  // IE's approach to draggable\n  if (display.scroller.dragDrop) { display.scroller.dragDrop() }\n  on(document, \"mouseup\", dragEnd)\n  on(display.scroller, \"drop\", dragEnd)\n}\n\n// Normal selection, as opposed to text dragging.\nfunction leftButtonSelect(cm, e, start, type, addNew) {\n  var display = cm.display, doc = cm.doc\n  e_preventDefault(e)\n\n  var ourRange, ourIndex, startSel = doc.sel, ranges = startSel.ranges\n  if (addNew && !e.shiftKey) {\n    ourIndex = doc.sel.contains(start)\n    if (ourIndex > -1)\n      { ourRange = ranges[ourIndex] }\n    else\n      { ourRange = new Range(start, start) }\n  } else {\n    ourRange = doc.sel.primary()\n    ourIndex = doc.sel.primIndex\n  }\n\n  if (chromeOS ? e.shiftKey && e.metaKey : e.altKey) {\n    type = \"rect\"\n    if (!addNew) { ourRange = new Range(start, start) }\n    start = posFromMouse(cm, e, true, true)\n    ourIndex = -1\n  } else if (type == \"double\") {\n    var word = cm.findWordAt(start)\n    if (cm.display.shift || doc.extend)\n      { ourRange = extendRange(doc, ourRange, word.anchor, word.head) }\n    else\n      { ourRange = word }\n  } else if (type == \"triple\") {\n    var line = new Range(Pos(start.line, 0), clipPos(doc, Pos(start.line + 1, 0)))\n    if (cm.display.shift || doc.extend)\n      { ourRange = extendRange(doc, ourRange, line.anchor, line.head) }\n    else\n      { ourRange = line }\n  } else {\n    ourRange = extendRange(doc, ourRange, start)\n  }\n\n  if (!addNew) {\n    ourIndex = 0\n    setSelection(doc, new Selection([ourRange], 0), sel_mouse)\n    startSel = doc.sel\n  } else if (ourIndex == -1) {\n    ourIndex = ranges.length\n    setSelection(doc, normalizeSelection(ranges.concat([ourRange]), ourIndex),\n                 {scroll: false, origin: \"*mouse\"})\n  } else if (ranges.length > 1 && ranges[ourIndex].empty() && type == \"single\" && !e.shiftKey) {\n    setSelection(doc, normalizeSelection(ranges.slice(0, ourIndex).concat(ranges.slice(ourIndex + 1)), 0),\n                 {scroll: false, origin: \"*mouse\"})\n    startSel = doc.sel\n  } else {\n    replaceOneSelection(doc, ourIndex, ourRange, sel_mouse)\n  }\n\n  var lastPos = start\n  function extendTo(pos) {\n    if (cmp(lastPos, pos) == 0) { return }\n    lastPos = pos\n\n    if (type == \"rect\") {\n      var ranges = [], tabSize = cm.options.tabSize\n      var startCol = countColumn(getLine(doc, start.line).text, start.ch, tabSize)\n      var posCol = countColumn(getLine(doc, pos.line).text, pos.ch, tabSize)\n      var left = Math.min(startCol, posCol), right = Math.max(startCol, posCol)\n      for (var line = Math.min(start.line, pos.line), end = Math.min(cm.lastLine(), Math.max(start.line, pos.line));\n           line <= end; line++) {\n        var text = getLine(doc, line).text, leftPos = findColumn(text, left, tabSize)\n        if (left == right)\n          { ranges.push(new Range(Pos(line, leftPos), Pos(line, leftPos))) }\n        else if (text.length > leftPos)\n          { ranges.push(new Range(Pos(line, leftPos), Pos(line, findColumn(text, right, tabSize)))) }\n      }\n      if (!ranges.length) { ranges.push(new Range(start, start)) }\n      setSelection(doc, normalizeSelection(startSel.ranges.slice(0, ourIndex).concat(ranges), ourIndex),\n                   {origin: \"*mouse\", scroll: false})\n      cm.scrollIntoView(pos)\n    } else {\n      var oldRange = ourRange\n      var anchor = oldRange.anchor, head = pos\n      if (type != \"single\") {\n        var range\n        if (type == \"double\")\n          { range = cm.findWordAt(pos) }\n        else\n          { range = new Range(Pos(pos.line, 0), clipPos(doc, Pos(pos.line + 1, 0))) }\n        if (cmp(range.anchor, anchor) > 0) {\n          head = range.head\n          anchor = minPos(oldRange.from(), range.anchor)\n        } else {\n          head = range.anchor\n          anchor = maxPos(oldRange.to(), range.head)\n        }\n      }\n      var ranges$1 = startSel.ranges.slice(0)\n      ranges$1[ourIndex] = new Range(clipPos(doc, anchor), head)\n      setSelection(doc, normalizeSelection(ranges$1, ourIndex), sel_mouse)\n    }\n  }\n\n  var editorSize = display.wrapper.getBoundingClientRect()\n  // Used to ensure timeout re-tries don't fire when another extend\n  // happened in the meantime (clearTimeout isn't reliable -- at\n  // least on Chrome, the timeouts still happen even when cleared,\n  // if the clear happens after their scheduled firing time).\n  var counter = 0\n\n  function extend(e) {\n    var curCount = ++counter\n    var cur = posFromMouse(cm, e, true, type == \"rect\")\n    if (!cur) { return }\n    if (cmp(cur, lastPos) != 0) {\n      cm.curOp.focus = activeElt()\n      extendTo(cur)\n      var visible = visibleLines(display, doc)\n      if (cur.line >= visible.to || cur.line < visible.from)\n        { setTimeout(operation(cm, function () {if (counter == curCount) { extend(e) }}), 150) }\n    } else {\n      var outside = e.clientY < editorSize.top ? -20 : e.clientY > editorSize.bottom ? 20 : 0\n      if (outside) { setTimeout(operation(cm, function () {\n        if (counter != curCount) { return }\n        display.scroller.scrollTop += outside\n        extend(e)\n      }), 50) }\n    }\n  }\n\n  function done(e) {\n    cm.state.selectingText = false\n    counter = Infinity\n    e_preventDefault(e)\n    display.input.focus()\n    off(document, \"mousemove\", move)\n    off(document, \"mouseup\", up)\n    doc.history.lastSelOrigin = null\n  }\n\n  var move = operation(cm, function (e) {\n    if (!e_button(e)) { done(e) }\n    else { extend(e) }\n  })\n  var up = operation(cm, done)\n  cm.state.selectingText = up\n  on(document, \"mousemove\", move)\n  on(document, \"mouseup\", up)\n}\n\n\n// Determines whether an event happened in the gutter, and fires the\n// handlers for the corresponding event.\nfunction gutterEvent(cm, e, type, prevent) {\n  var mX, mY\n  try { mX = e.clientX; mY = e.clientY }\n  catch(e) { return false }\n  if (mX >= Math.floor(cm.display.gutters.getBoundingClientRect().right)) { return false }\n  if (prevent) { e_preventDefault(e) }\n\n  var display = cm.display\n  var lineBox = display.lineDiv.getBoundingClientRect()\n\n  if (mY > lineBox.bottom || !hasHandler(cm, type)) { return e_defaultPrevented(e) }\n  mY -= lineBox.top - display.viewOffset\n\n  for (var i = 0; i < cm.options.gutters.length; ++i) {\n    var g = display.gutters.childNodes[i]\n    if (g && g.getBoundingClientRect().right >= mX) {\n      var line = lineAtHeight(cm.doc, mY)\n      var gutter = cm.options.gutters[i]\n      signal(cm, type, cm, line, gutter, e)\n      return e_defaultPrevented(e)\n    }\n  }\n}\n\nfunction clickInGutter(cm, e) {\n  return gutterEvent(cm, e, \"gutterClick\", true)\n}\n\n// CONTEXT MENU HANDLING\n\n// To make the context menu work, we need to briefly unhide the\n// textarea (making it as unobtrusive as possible) to let the\n// right-click take effect on it.\nfunction onContextMenu(cm, e) {\n  if (eventInWidget(cm.display, e) || contextMenuInGutter(cm, e)) { return }\n  if (signalDOMEvent(cm, e, \"contextmenu\")) { return }\n  cm.display.input.onContextMenu(e)\n}\n\nfunction contextMenuInGutter(cm, e) {\n  if (!hasHandler(cm, \"gutterContextMenu\")) { return false }\n  return gutterEvent(cm, e, \"gutterContextMenu\", false)\n}\n\nfunction themeChanged(cm) {\n  cm.display.wrapper.className = cm.display.wrapper.className.replace(/\\s*cm-s-\\S+/g, \"\") +\n    cm.options.theme.replace(/(^|\\s)\\s*/g, \" cm-s-\")\n  clearCaches(cm)\n}\n\nvar Init = {toString: function(){return \"CodeMirror.Init\"}}\n\nvar defaults = {}\nvar optionHandlers = {}\n\nfunction defineOptions(CodeMirror) {\n  var optionHandlers = CodeMirror.optionHandlers\n\n  function option(name, deflt, handle, notOnInit) {\n    CodeMirror.defaults[name] = deflt\n    if (handle) { optionHandlers[name] =\n      notOnInit ? function (cm, val, old) {if (old != Init) { handle(cm, val, old) }} : handle }\n  }\n\n  CodeMirror.defineOption = option\n\n  // Passed to option handlers when there is no old value.\n  CodeMirror.Init = Init\n\n  // These two are, on init, called from the constructor because they\n  // have to be initialized before the editor can start at all.\n  option(\"value\", \"\", function (cm, val) { return cm.setValue(val); }, true)\n  option(\"mode\", null, function (cm, val) {\n    cm.doc.modeOption = val\n    loadMode(cm)\n  }, true)\n\n  option(\"indentUnit\", 2, loadMode, true)\n  option(\"indentWithTabs\", false)\n  option(\"smartIndent\", true)\n  option(\"tabSize\", 4, function (cm) {\n    resetModeState(cm)\n    clearCaches(cm)\n    regChange(cm)\n  }, true)\n  option(\"lineSeparator\", null, function (cm, val) {\n    cm.doc.lineSep = val\n    if (!val) { return }\n    var newBreaks = [], lineNo = cm.doc.first\n    cm.doc.iter(function (line) {\n      for (var pos = 0;;) {\n        var found = line.text.indexOf(val, pos)\n        if (found == -1) { break }\n        pos = found + val.length\n        newBreaks.push(Pos(lineNo, found))\n      }\n      lineNo++\n    })\n    for (var i = newBreaks.length - 1; i >= 0; i--)\n      { replaceRange(cm.doc, val, newBreaks[i], Pos(newBreaks[i].line, newBreaks[i].ch + val.length)) }\n  })\n  option(\"specialChars\", /[\\u0000-\\u001f\\u007f\\u00ad\\u061c\\u200b-\\u200f\\u2028\\u2029\\ufeff]/g, function (cm, val, old) {\n    cm.state.specialChars = new RegExp(val.source + (val.test(\"\\t\") ? \"\" : \"|\\t\"), \"g\")\n    if (old != Init) { cm.refresh() }\n  })\n  option(\"specialCharPlaceholder\", defaultSpecialCharPlaceholder, function (cm) { return cm.refresh(); }, true)\n  option(\"electricChars\", true)\n  option(\"inputStyle\", mobile ? \"contenteditable\" : \"textarea\", function () {\n    throw new Error(\"inputStyle can not (yet) be changed in a running editor\") // FIXME\n  }, true)\n  option(\"spellcheck\", false, function (cm, val) { return cm.getInputField().spellcheck = val; }, true)\n  option(\"rtlMoveVisually\", !windows)\n  option(\"wholeLineUpdateBefore\", true)\n\n  option(\"theme\", \"default\", function (cm) {\n    themeChanged(cm)\n    guttersChanged(cm)\n  }, true)\n  option(\"keyMap\", \"default\", function (cm, val, old) {\n    var next = getKeyMap(val)\n    var prev = old != Init && getKeyMap(old)\n    if (prev && prev.detach) { prev.detach(cm, next) }\n    if (next.attach) { next.attach(cm, prev || null) }\n  })\n  option(\"extraKeys\", null)\n\n  option(\"lineWrapping\", false, wrappingChanged, true)\n  option(\"gutters\", [], function (cm) {\n    setGuttersForLineNumbers(cm.options)\n    guttersChanged(cm)\n  }, true)\n  option(\"fixedGutter\", true, function (cm, val) {\n    cm.display.gutters.style.left = val ? compensateForHScroll(cm.display) + \"px\" : \"0\"\n    cm.refresh()\n  }, true)\n  option(\"coverGutterNextToScrollbar\", false, function (cm) { return updateScrollbars(cm); }, true)\n  option(\"scrollbarStyle\", \"native\", function (cm) {\n    initScrollbars(cm)\n    updateScrollbars(cm)\n    cm.display.scrollbars.setScrollTop(cm.doc.scrollTop)\n    cm.display.scrollbars.setScrollLeft(cm.doc.scrollLeft)\n  }, true)\n  option(\"lineNumbers\", false, function (cm) {\n    setGuttersForLineNumbers(cm.options)\n    guttersChanged(cm)\n  }, true)\n  option(\"firstLineNumber\", 1, guttersChanged, true)\n  option(\"lineNumberFormatter\", function (integer) { return integer; }, guttersChanged, true)\n  option(\"showCursorWhenSelecting\", false, updateSelection, true)\n\n  option(\"resetSelectionOnContextMenu\", true)\n  option(\"lineWiseCopyCut\", true)\n\n  option(\"readOnly\", false, function (cm, val) {\n    if (val == \"nocursor\") {\n      onBlur(cm)\n      cm.display.input.blur()\n      cm.display.disabled = true\n    } else {\n      cm.display.disabled = false\n    }\n    cm.display.input.readOnlyChanged(val)\n  })\n  option(\"disableInput\", false, function (cm, val) {if (!val) { cm.display.input.reset() }}, true)\n  option(\"dragDrop\", true, dragDropChanged)\n  option(\"allowDropFileTypes\", null)\n\n  option(\"cursorBlinkRate\", 530)\n  option(\"cursorScrollMargin\", 0)\n  option(\"cursorHeight\", 1, updateSelection, true)\n  option(\"singleCursorHeightPerLine\", true, updateSelection, true)\n  option(\"workTime\", 100)\n  option(\"workDelay\", 100)\n  option(\"flattenSpans\", true, resetModeState, true)\n  option(\"addModeClass\", false, resetModeState, true)\n  option(\"pollInterval\", 100)\n  option(\"undoDepth\", 200, function (cm, val) { return cm.doc.history.undoDepth = val; })\n  option(\"historyEventDelay\", 1250)\n  option(\"viewportMargin\", 10, function (cm) { return cm.refresh(); }, true)\n  option(\"maxHighlightLength\", 10000, resetModeState, true)\n  option(\"moveInputWithCursor\", true, function (cm, val) {\n    if (!val) { cm.display.input.resetPosition() }\n  })\n\n  option(\"tabindex\", null, function (cm, val) { return cm.display.input.getField().tabIndex = val || \"\"; })\n  option(\"autofocus\", null)\n}\n\nfunction guttersChanged(cm) {\n  updateGutters(cm)\n  regChange(cm)\n  alignHorizontally(cm)\n}\n\nfunction dragDropChanged(cm, value, old) {\n  var wasOn = old && old != Init\n  if (!value != !wasOn) {\n    var funcs = cm.display.dragFunctions\n    var toggle = value ? on : off\n    toggle(cm.display.scroller, \"dragstart\", funcs.start)\n    toggle(cm.display.scroller, \"dragenter\", funcs.enter)\n    toggle(cm.display.scroller, \"dragover\", funcs.over)\n    toggle(cm.display.scroller, \"dragleave\", funcs.leave)\n    toggle(cm.display.scroller, \"drop\", funcs.drop)\n  }\n}\n\nfunction wrappingChanged(cm) {\n  if (cm.options.lineWrapping) {\n    addClass(cm.display.wrapper, \"CodeMirror-wrap\")\n    cm.display.sizer.style.minWidth = \"\"\n    cm.display.sizerWidth = null\n  } else {\n    rmClass(cm.display.wrapper, \"CodeMirror-wrap\")\n    findMaxLine(cm)\n  }\n  estimateLineHeights(cm)\n  regChange(cm)\n  clearCaches(cm)\n  setTimeout(function () { return updateScrollbars(cm); }, 100)\n}\n\n// A CodeMirror instance represents an editor. This is the object\n// that user code is usually dealing with.\n\nfunction CodeMirror(place, options) {\n  var this$1 = this;\n\n  if (!(this instanceof CodeMirror)) { return new CodeMirror(place, options) }\n\n  this.options = options = options ? copyObj(options) : {}\n  // Determine effective options based on given values and defaults.\n  copyObj(defaults, options, false)\n  setGuttersForLineNumbers(options)\n\n  var doc = options.value\n  if (typeof doc == \"string\") { doc = new Doc(doc, options.mode, null, options.lineSeparator) }\n  this.doc = doc\n\n  var input = new CodeMirror.inputStyles[options.inputStyle](this)\n  var display = this.display = new Display(place, doc, input)\n  display.wrapper.CodeMirror = this\n  updateGutters(this)\n  themeChanged(this)\n  if (options.lineWrapping)\n    { this.display.wrapper.className += \" CodeMirror-wrap\" }\n  initScrollbars(this)\n\n  this.state = {\n    keyMaps: [],  // stores maps added by addKeyMap\n    overlays: [], // highlighting overlays, as added by addOverlay\n    modeGen: 0,   // bumped when mode/overlay changes, used to invalidate highlighting info\n    overwrite: false,\n    delayingBlurEvent: false,\n    focused: false,\n    suppressEdits: false, // used to disable editing during key handlers when in readOnly mode\n    pasteIncoming: false, cutIncoming: false, // help recognize paste/cut edits in input.poll\n    selectingText: false,\n    draggingText: false,\n    highlight: new Delayed(), // stores highlight worker timeout\n    keySeq: null,  // Unfinished key sequence\n    specialChars: null\n  }\n\n  if (options.autofocus && !mobile) { display.input.focus() }\n\n  // Override magic textarea content restore that IE sometimes does\n  // on our hidden textarea on reload\n  if (ie && ie_version < 11) { setTimeout(function () { return this$1.display.input.reset(true); }, 20) }\n\n  registerEventHandlers(this)\n  ensureGlobalHandlers()\n\n  startOperation(this)\n  this.curOp.forceUpdate = true\n  attachDoc(this, doc)\n\n  if ((options.autofocus && !mobile) || this.hasFocus())\n    { setTimeout(bind(onFocus, this), 20) }\n  else\n    { onBlur(this) }\n\n  for (var opt in optionHandlers) { if (optionHandlers.hasOwnProperty(opt))\n    { optionHandlers[opt](this$1, options[opt], Init) } }\n  maybeUpdateLineNumberWidth(this)\n  if (options.finishInit) { options.finishInit(this) }\n  for (var i = 0; i < initHooks.length; ++i) { initHooks[i](this$1) }\n  endOperation(this)\n  // Suppress optimizelegibility in Webkit, since it breaks text\n  // measuring on line wrapping boundaries.\n  if (webkit && options.lineWrapping &&\n      getComputedStyle(display.lineDiv).textRendering == \"optimizelegibility\")\n    { display.lineDiv.style.textRendering = \"auto\" }\n}\n\n// The default configuration options.\nCodeMirror.defaults = defaults\n// Functions to run when options are changed.\nCodeMirror.optionHandlers = optionHandlers\n\n// Attach the necessary event handlers when initializing the editor\nfunction registerEventHandlers(cm) {\n  var d = cm.display\n  on(d.scroller, \"mousedown\", operation(cm, onMouseDown))\n  // Older IE's will not fire a second mousedown for a double click\n  if (ie && ie_version < 11)\n    { on(d.scroller, \"dblclick\", operation(cm, function (e) {\n      if (signalDOMEvent(cm, e)) { return }\n      var pos = posFromMouse(cm, e)\n      if (!pos || clickInGutter(cm, e) || eventInWidget(cm.display, e)) { return }\n      e_preventDefault(e)\n      var word = cm.findWordAt(pos)\n      extendSelection(cm.doc, word.anchor, word.head)\n    })) }\n  else\n    { on(d.scroller, \"dblclick\", function (e) { return signalDOMEvent(cm, e) || e_preventDefault(e); }) }\n  // Some browsers fire contextmenu *after* opening the menu, at\n  // which point we can't mess with it anymore. Context menu is\n  // handled in onMouseDown for these browsers.\n  if (!captureRightClick) { on(d.scroller, \"contextmenu\", function (e) { return onContextMenu(cm, e); }) }\n\n  // Used to suppress mouse event handling when a touch happens\n  var touchFinished, prevTouch = {end: 0}\n  function finishTouch() {\n    if (d.activeTouch) {\n      touchFinished = setTimeout(function () { return d.activeTouch = null; }, 1000)\n      prevTouch = d.activeTouch\n      prevTouch.end = +new Date\n    }\n  }\n  function isMouseLikeTouchEvent(e) {\n    if (e.touches.length != 1) { return false }\n    var touch = e.touches[0]\n    return touch.radiusX <= 1 && touch.radiusY <= 1\n  }\n  function farAway(touch, other) {\n    if (other.left == null) { return true }\n    var dx = other.left - touch.left, dy = other.top - touch.top\n    return dx * dx + dy * dy > 20 * 20\n  }\n  on(d.scroller, \"touchstart\", function (e) {\n    if (!signalDOMEvent(cm, e) && !isMouseLikeTouchEvent(e)) {\n      d.input.ensurePolled()\n      clearTimeout(touchFinished)\n      var now = +new Date\n      d.activeTouch = {start: now, moved: false,\n                       prev: now - prevTouch.end <= 300 ? prevTouch : null}\n      if (e.touches.length == 1) {\n        d.activeTouch.left = e.touches[0].pageX\n        d.activeTouch.top = e.touches[0].pageY\n      }\n    }\n  })\n  on(d.scroller, \"touchmove\", function () {\n    if (d.activeTouch) { d.activeTouch.moved = true }\n  })\n  on(d.scroller, \"touchend\", function (e) {\n    var touch = d.activeTouch\n    if (touch && !eventInWidget(d, e) && touch.left != null &&\n        !touch.moved && new Date - touch.start < 300) {\n      var pos = cm.coordsChar(d.activeTouch, \"page\"), range\n      if (!touch.prev || farAway(touch, touch.prev)) // Single tap\n        { range = new Range(pos, pos) }\n      else if (!touch.prev.prev || farAway(touch, touch.prev.prev)) // Double tap\n        { range = cm.findWordAt(pos) }\n      else // Triple tap\n        { range = new Range(Pos(pos.line, 0), clipPos(cm.doc, Pos(pos.line + 1, 0))) }\n      cm.setSelection(range.anchor, range.head)\n      cm.focus()\n      e_preventDefault(e)\n    }\n    finishTouch()\n  })\n  on(d.scroller, \"touchcancel\", finishTouch)\n\n  // Sync scrolling between fake scrollbars and real scrollable\n  // area, ensure viewport is updated when scrolling.\n  on(d.scroller, \"scroll\", function () {\n    if (d.scroller.clientHeight) {\n      setScrollTop(cm, d.scroller.scrollTop)\n      setScrollLeft(cm, d.scroller.scrollLeft, true)\n      signal(cm, \"scroll\", cm)\n    }\n  })\n\n  // Listen to wheel events in order to try and update the viewport on time.\n  on(d.scroller, \"mousewheel\", function (e) { return onScrollWheel(cm, e); })\n  on(d.scroller, \"DOMMouseScroll\", function (e) { return onScrollWheel(cm, e); })\n\n  // Prevent wrapper from ever scrolling\n  on(d.wrapper, \"scroll\", function () { return d.wrapper.scrollTop = d.wrapper.scrollLeft = 0; })\n\n  d.dragFunctions = {\n    enter: function (e) {if (!signalDOMEvent(cm, e)) { e_stop(e) }},\n    over: function (e) {if (!signalDOMEvent(cm, e)) { onDragOver(cm, e); e_stop(e) }},\n    start: function (e) { return onDragStart(cm, e); },\n    drop: operation(cm, onDrop),\n    leave: function (e) {if (!signalDOMEvent(cm, e)) { clearDragCursor(cm) }}\n  }\n\n  var inp = d.input.getField()\n  on(inp, \"keyup\", function (e) { return onKeyUp.call(cm, e); })\n  on(inp, \"keydown\", operation(cm, onKeyDown))\n  on(inp, \"keypress\", operation(cm, onKeyPress))\n  on(inp, \"focus\", function (e) { return onFocus(cm, e); })\n  on(inp, \"blur\", function (e) { return onBlur(cm, e); })\n}\n\nvar initHooks = []\nCodeMirror.defineInitHook = function (f) { return initHooks.push(f); }\n\n// Indent the given line. The how parameter can be \"smart\",\n// \"add\"/null, \"subtract\", or \"prev\". When aggressive is false\n// (typically set to true for forced single-line indents), empty\n// lines are not indented, and places where the mode returns Pass\n// are left alone.\nfunction indentLine(cm, n, how, aggressive) {\n  var doc = cm.doc, state\n  if (how == null) { how = \"add\" }\n  if (how == \"smart\") {\n    // Fall back to \"prev\" when the mode doesn't have an indentation\n    // method.\n    if (!doc.mode.indent) { how = \"prev\" }\n    else { state = getStateBefore(cm, n) }\n  }\n\n  var tabSize = cm.options.tabSize\n  var line = getLine(doc, n), curSpace = countColumn(line.text, null, tabSize)\n  if (line.stateAfter) { line.stateAfter = null }\n  var curSpaceString = line.text.match(/^\\s*/)[0], indentation\n  if (!aggressive && !/\\S/.test(line.text)) {\n    indentation = 0\n    how = \"not\"\n  } else if (how == \"smart\") {\n    indentation = doc.mode.indent(state, line.text.slice(curSpaceString.length), line.text)\n    if (indentation == Pass || indentation > 150) {\n      if (!aggressive) { return }\n      how = \"prev\"\n    }\n  }\n  if (how == \"prev\") {\n    if (n > doc.first) { indentation = countColumn(getLine(doc, n-1).text, null, tabSize) }\n    else { indentation = 0 }\n  } else if (how == \"add\") {\n    indentation = curSpace + cm.options.indentUnit\n  } else if (how == \"subtract\") {\n    indentation = curSpace - cm.options.indentUnit\n  } else if (typeof how == \"number\") {\n    indentation = curSpace + how\n  }\n  indentation = Math.max(0, indentation)\n\n  var indentString = \"\", pos = 0\n  if (cm.options.indentWithTabs)\n    { for (var i = Math.floor(indentation / tabSize); i; --i) {pos += tabSize; indentString += \"\\t\"} }\n  if (pos < indentation) { indentString += spaceStr(indentation - pos) }\n\n  if (indentString != curSpaceString) {\n    replaceRange(doc, indentString, Pos(n, 0), Pos(n, curSpaceString.length), \"+input\")\n    line.stateAfter = null\n    return true\n  } else {\n    // Ensure that, if the cursor was in the whitespace at the start\n    // of the line, it is moved to the end of that space.\n    for (var i$1 = 0; i$1 < doc.sel.ranges.length; i$1++) {\n      var range = doc.sel.ranges[i$1]\n      if (range.head.line == n && range.head.ch < curSpaceString.length) {\n        var pos$1 = Pos(n, curSpaceString.length)\n        replaceOneSelection(doc, i$1, new Range(pos$1, pos$1))\n        break\n      }\n    }\n  }\n}\n\n// This will be set to a {lineWise: bool, text: [string]} object, so\n// that, when pasting, we know what kind of selections the copied\n// text was made out of.\nvar lastCopied = null\n\nfunction setLastCopied(newLastCopied) {\n  lastCopied = newLastCopied\n}\n\nfunction applyTextInput(cm, inserted, deleted, sel, origin) {\n  var doc = cm.doc\n  cm.display.shift = false\n  if (!sel) { sel = doc.sel }\n\n  var paste = cm.state.pasteIncoming || origin == \"paste\"\n  var textLines = splitLinesAuto(inserted), multiPaste = null\n  // When pasing N lines into N selections, insert one line per selection\n  if (paste && sel.ranges.length > 1) {\n    if (lastCopied && lastCopied.text.join(\"\\n\") == inserted) {\n      if (sel.ranges.length % lastCopied.text.length == 0) {\n        multiPaste = []\n        for (var i = 0; i < lastCopied.text.length; i++)\n          { multiPaste.push(doc.splitLines(lastCopied.text[i])) }\n      }\n    } else if (textLines.length == sel.ranges.length) {\n      multiPaste = map(textLines, function (l) { return [l]; })\n    }\n  }\n\n  var updateInput\n  // Normal behavior is to insert the new text into every selection\n  for (var i$1 = sel.ranges.length - 1; i$1 >= 0; i$1--) {\n    var range = sel.ranges[i$1]\n    var from = range.from(), to = range.to()\n    if (range.empty()) {\n      if (deleted && deleted > 0) // Handle deletion\n        { from = Pos(from.line, from.ch - deleted) }\n      else if (cm.state.overwrite && !paste) // Handle overwrite\n        { to = Pos(to.line, Math.min(getLine(doc, to.line).text.length, to.ch + lst(textLines).length)) }\n      else if (lastCopied && lastCopied.lineWise && lastCopied.text.join(\"\\n\") == inserted)\n        { from = to = Pos(from.line, 0) }\n    }\n    updateInput = cm.curOp.updateInput\n    var changeEvent = {from: from, to: to, text: multiPaste ? multiPaste[i$1 % multiPaste.length] : textLines,\n                       origin: origin || (paste ? \"paste\" : cm.state.cutIncoming ? \"cut\" : \"+input\")}\n    makeChange(cm.doc, changeEvent)\n    signalLater(cm, \"inputRead\", cm, changeEvent)\n  }\n  if (inserted && !paste)\n    { triggerElectric(cm, inserted) }\n\n  ensureCursorVisible(cm)\n  cm.curOp.updateInput = updateInput\n  cm.curOp.typing = true\n  cm.state.pasteIncoming = cm.state.cutIncoming = false\n}\n\nfunction handlePaste(e, cm) {\n  var pasted = e.clipboardData && e.clipboardData.getData(\"Text\")\n  if (pasted) {\n    e.preventDefault()\n    if (!cm.isReadOnly() && !cm.options.disableInput)\n      { runInOp(cm, function () { return applyTextInput(cm, pasted, 0, null, \"paste\"); }) }\n    return true\n  }\n}\n\nfunction triggerElectric(cm, inserted) {\n  // When an 'electric' character is inserted, immediately trigger a reindent\n  if (!cm.options.electricChars || !cm.options.smartIndent) { return }\n  var sel = cm.doc.sel\n\n  for (var i = sel.ranges.length - 1; i >= 0; i--) {\n    var range = sel.ranges[i]\n    if (range.head.ch > 100 || (i && sel.ranges[i - 1].head.line == range.head.line)) { continue }\n    var mode = cm.getModeAt(range.head)\n    var indented = false\n    if (mode.electricChars) {\n      for (var j = 0; j < mode.electricChars.length; j++)\n        { if (inserted.indexOf(mode.electricChars.charAt(j)) > -1) {\n          indented = indentLine(cm, range.head.line, \"smart\")\n          break\n        } }\n    } else if (mode.electricInput) {\n      if (mode.electricInput.test(getLine(cm.doc, range.head.line).text.slice(0, range.head.ch)))\n        { indented = indentLine(cm, range.head.line, \"smart\") }\n    }\n    if (indented) { signalLater(cm, \"electricInput\", cm, range.head.line) }\n  }\n}\n\nfunction copyableRanges(cm) {\n  var text = [], ranges = []\n  for (var i = 0; i < cm.doc.sel.ranges.length; i++) {\n    var line = cm.doc.sel.ranges[i].head.line\n    var lineRange = {anchor: Pos(line, 0), head: Pos(line + 1, 0)}\n    ranges.push(lineRange)\n    text.push(cm.getRange(lineRange.anchor, lineRange.head))\n  }\n  return {text: text, ranges: ranges}\n}\n\nfunction disableBrowserMagic(field, spellcheck) {\n  field.setAttribute(\"autocorrect\", \"off\")\n  field.setAttribute(\"autocapitalize\", \"off\")\n  field.setAttribute(\"spellcheck\", !!spellcheck)\n}\n\nfunction hiddenTextarea() {\n  var te = elt(\"textarea\", null, null, \"position: absolute; bottom: -1em; padding: 0; width: 1px; height: 1em; outline: none\")\n  var div = elt(\"div\", [te], null, \"overflow: hidden; position: relative; width: 3px; height: 0px;\")\n  // The textarea is kept positioned near the cursor to prevent the\n  // fact that it'll be scrolled into view on input from scrolling\n  // our fake cursor out of view. On webkit, when wrap=off, paste is\n  // very slow. So make the area wide instead.\n  if (webkit) { te.style.width = \"1000px\" }\n  else { te.setAttribute(\"wrap\", \"off\") }\n  // If border: 0; -- iOS fails to open keyboard (issue #1287)\n  if (ios) { te.style.border = \"1px solid black\" }\n  disableBrowserMagic(te)\n  return div\n}\n\n// The publicly visible API. Note that methodOp(f) means\n// 'wrap f in an operation, performed on its `this` parameter'.\n\n// This is not the complete set of editor methods. Most of the\n// methods defined on the Doc type are also injected into\n// CodeMirror.prototype, for backwards compatibility and\n// convenience.\n\nfunction addEditorMethods(CodeMirror) {\n  var optionHandlers = CodeMirror.optionHandlers\n\n  var helpers = CodeMirror.helpers = {}\n\n  CodeMirror.prototype = {\n    constructor: CodeMirror,\n    focus: function(){window.focus(); this.display.input.focus()},\n\n    setOption: function(option, value) {\n      var options = this.options, old = options[option]\n      if (options[option] == value && option != \"mode\") { return }\n      options[option] = value\n      if (optionHandlers.hasOwnProperty(option))\n        { operation(this, optionHandlers[option])(this, value, old) }\n      signal(this, \"optionChange\", this, option)\n    },\n\n    getOption: function(option) {return this.options[option]},\n    getDoc: function() {return this.doc},\n\n    addKeyMap: function(map, bottom) {\n      this.state.keyMaps[bottom ? \"push\" : \"unshift\"](getKeyMap(map))\n    },\n    removeKeyMap: function(map) {\n      var maps = this.state.keyMaps\n      for (var i = 0; i < maps.length; ++i)\n        { if (maps[i] == map || maps[i].name == map) {\n          maps.splice(i, 1)\n          return true\n        } }\n    },\n\n    addOverlay: methodOp(function(spec, options) {\n      var mode = spec.token ? spec : CodeMirror.getMode(this.options, spec)\n      if (mode.startState) { throw new Error(\"Overlays may not be stateful.\") }\n      insertSorted(this.state.overlays,\n                   {mode: mode, modeSpec: spec, opaque: options && options.opaque,\n                    priority: (options && options.priority) || 0},\n                   function (overlay) { return overlay.priority; })\n      this.state.modeGen++\n      regChange(this)\n    }),\n    removeOverlay: methodOp(function(spec) {\n      var this$1 = this;\n\n      var overlays = this.state.overlays\n      for (var i = 0; i < overlays.length; ++i) {\n        var cur = overlays[i].modeSpec\n        if (cur == spec || typeof spec == \"string\" && cur.name == spec) {\n          overlays.splice(i, 1)\n          this$1.state.modeGen++\n          regChange(this$1)\n          return\n        }\n      }\n    }),\n\n    indentLine: methodOp(function(n, dir, aggressive) {\n      if (typeof dir != \"string\" && typeof dir != \"number\") {\n        if (dir == null) { dir = this.options.smartIndent ? \"smart\" : \"prev\" }\n        else { dir = dir ? \"add\" : \"subtract\" }\n      }\n      if (isLine(this.doc, n)) { indentLine(this, n, dir, aggressive) }\n    }),\n    indentSelection: methodOp(function(how) {\n      var this$1 = this;\n\n      var ranges = this.doc.sel.ranges, end = -1\n      for (var i = 0; i < ranges.length; i++) {\n        var range = ranges[i]\n        if (!range.empty()) {\n          var from = range.from(), to = range.to()\n          var start = Math.max(end, from.line)\n          end = Math.min(this$1.lastLine(), to.line - (to.ch ? 0 : 1)) + 1\n          for (var j = start; j < end; ++j)\n            { indentLine(this$1, j, how) }\n          var newRanges = this$1.doc.sel.ranges\n          if (from.ch == 0 && ranges.length == newRanges.length && newRanges[i].from().ch > 0)\n            { replaceOneSelection(this$1.doc, i, new Range(from, newRanges[i].to()), sel_dontScroll) }\n        } else if (range.head.line > end) {\n          indentLine(this$1, range.head.line, how, true)\n          end = range.head.line\n          if (i == this$1.doc.sel.primIndex) { ensureCursorVisible(this$1) }\n        }\n      }\n    }),\n\n    // Fetch the parser token for a given character. Useful for hacks\n    // that want to inspect the mode state (say, for completion).\n    getTokenAt: function(pos, precise) {\n      return takeToken(this, pos, precise)\n    },\n\n    getLineTokens: function(line, precise) {\n      return takeToken(this, Pos(line), precise, true)\n    },\n\n    getTokenTypeAt: function(pos) {\n      pos = clipPos(this.doc, pos)\n      var styles = getLineStyles(this, getLine(this.doc, pos.line))\n      var before = 0, after = (styles.length - 1) / 2, ch = pos.ch\n      var type\n      if (ch == 0) { type = styles[2] }\n      else { for (;;) {\n        var mid = (before + after) >> 1\n        if ((mid ? styles[mid * 2 - 1] : 0) >= ch) { after = mid }\n        else if (styles[mid * 2 + 1] < ch) { before = mid + 1 }\n        else { type = styles[mid * 2 + 2]; break }\n      } }\n      var cut = type ? type.indexOf(\"overlay \") : -1\n      return cut < 0 ? type : cut == 0 ? null : type.slice(0, cut - 1)\n    },\n\n    getModeAt: function(pos) {\n      var mode = this.doc.mode\n      if (!mode.innerMode) { return mode }\n      return CodeMirror.innerMode(mode, this.getTokenAt(pos).state).mode\n    },\n\n    getHelper: function(pos, type) {\n      return this.getHelpers(pos, type)[0]\n    },\n\n    getHelpers: function(pos, type) {\n      var this$1 = this;\n\n      var found = []\n      if (!helpers.hasOwnProperty(type)) { return found }\n      var help = helpers[type], mode = this.getModeAt(pos)\n      if (typeof mode[type] == \"string\") {\n        if (help[mode[type]]) { found.push(help[mode[type]]) }\n      } else if (mode[type]) {\n        for (var i = 0; i < mode[type].length; i++) {\n          var val = help[mode[type][i]]\n          if (val) { found.push(val) }\n        }\n      } else if (mode.helperType && help[mode.helperType]) {\n        found.push(help[mode.helperType])\n      } else if (help[mode.name]) {\n        found.push(help[mode.name])\n      }\n      for (var i$1 = 0; i$1 < help._global.length; i$1++) {\n        var cur = help._global[i$1]\n        if (cur.pred(mode, this$1) && indexOf(found, cur.val) == -1)\n          { found.push(cur.val) }\n      }\n      return found\n    },\n\n    getStateAfter: function(line, precise) {\n      var doc = this.doc\n      line = clipLine(doc, line == null ? doc.first + doc.size - 1: line)\n      return getStateBefore(this, line + 1, precise)\n    },\n\n    cursorCoords: function(start, mode) {\n      var pos, range = this.doc.sel.primary()\n      if (start == null) { pos = range.head }\n      else if (typeof start == \"object\") { pos = clipPos(this.doc, start) }\n      else { pos = start ? range.from() : range.to() }\n      return cursorCoords(this, pos, mode || \"page\")\n    },\n\n    charCoords: function(pos, mode) {\n      return charCoords(this, clipPos(this.doc, pos), mode || \"page\")\n    },\n\n    coordsChar: function(coords, mode) {\n      coords = fromCoordSystem(this, coords, mode || \"page\")\n      return coordsChar(this, coords.left, coords.top)\n    },\n\n    lineAtHeight: function(height, mode) {\n      height = fromCoordSystem(this, {top: height, left: 0}, mode || \"page\").top\n      return lineAtHeight(this.doc, height + this.display.viewOffset)\n    },\n    heightAtLine: function(line, mode, includeWidgets) {\n      var end = false, lineObj\n      if (typeof line == \"number\") {\n        var last = this.doc.first + this.doc.size - 1\n        if (line < this.doc.first) { line = this.doc.first }\n        else if (line > last) { line = last; end = true }\n        lineObj = getLine(this.doc, line)\n      } else {\n        lineObj = line\n      }\n      return intoCoordSystem(this, lineObj, {top: 0, left: 0}, mode || \"page\", includeWidgets || end).top +\n        (end ? this.doc.height - heightAtLine(lineObj) : 0)\n    },\n\n    defaultTextHeight: function() { return textHeight(this.display) },\n    defaultCharWidth: function() { return charWidth(this.display) },\n\n    getViewport: function() { return {from: this.display.viewFrom, to: this.display.viewTo}},\n\n    addWidget: function(pos, node, scroll, vert, horiz) {\n      var display = this.display\n      pos = cursorCoords(this, clipPos(this.doc, pos))\n      var top = pos.bottom, left = pos.left\n      node.style.position = \"absolute\"\n      node.setAttribute(\"cm-ignore-events\", \"true\")\n      this.display.input.setUneditable(node)\n      display.sizer.appendChild(node)\n      if (vert == \"over\") {\n        top = pos.top\n      } else if (vert == \"above\" || vert == \"near\") {\n        var vspace = Math.max(display.wrapper.clientHeight, this.doc.height),\n        hspace = Math.max(display.sizer.clientWidth, display.lineSpace.clientWidth)\n        // Default to positioning above (if specified and possible); otherwise default to positioning below\n        if ((vert == 'above' || pos.bottom + node.offsetHeight > vspace) && pos.top > node.offsetHeight)\n          { top = pos.top - node.offsetHeight }\n        else if (pos.bottom + node.offsetHeight <= vspace)\n          { top = pos.bottom }\n        if (left + node.offsetWidth > hspace)\n          { left = hspace - node.offsetWidth }\n      }\n      node.style.top = top + \"px\"\n      node.style.left = node.style.right = \"\"\n      if (horiz == \"right\") {\n        left = display.sizer.clientWidth - node.offsetWidth\n        node.style.right = \"0px\"\n      } else {\n        if (horiz == \"left\") { left = 0 }\n        else if (horiz == \"middle\") { left = (display.sizer.clientWidth - node.offsetWidth) / 2 }\n        node.style.left = left + \"px\"\n      }\n      if (scroll)\n        { scrollIntoView(this, left, top, left + node.offsetWidth, top + node.offsetHeight) }\n    },\n\n    triggerOnKeyDown: methodOp(onKeyDown),\n    triggerOnKeyPress: methodOp(onKeyPress),\n    triggerOnKeyUp: onKeyUp,\n\n    execCommand: function(cmd) {\n      if (commands.hasOwnProperty(cmd))\n        { return commands[cmd].call(null, this) }\n    },\n\n    triggerElectric: methodOp(function(text) { triggerElectric(this, text) }),\n\n    findPosH: function(from, amount, unit, visually) {\n      var this$1 = this;\n\n      var dir = 1\n      if (amount < 0) { dir = -1; amount = -amount }\n      var cur = clipPos(this.doc, from)\n      for (var i = 0; i < amount; ++i) {\n        cur = findPosH(this$1.doc, cur, dir, unit, visually)\n        if (cur.hitSide) { break }\n      }\n      return cur\n    },\n\n    moveH: methodOp(function(dir, unit) {\n      var this$1 = this;\n\n      this.extendSelectionsBy(function (range) {\n        if (this$1.display.shift || this$1.doc.extend || range.empty())\n          { return findPosH(this$1.doc, range.head, dir, unit, this$1.options.rtlMoveVisually) }\n        else\n          { return dir < 0 ? range.from() : range.to() }\n      }, sel_move)\n    }),\n\n    deleteH: methodOp(function(dir, unit) {\n      var sel = this.doc.sel, doc = this.doc\n      if (sel.somethingSelected())\n        { doc.replaceSelection(\"\", null, \"+delete\") }\n      else\n        { deleteNearSelection(this, function (range) {\n          var other = findPosH(doc, range.head, dir, unit, false)\n          return dir < 0 ? {from: other, to: range.head} : {from: range.head, to: other}\n        }) }\n    }),\n\n    findPosV: function(from, amount, unit, goalColumn) {\n      var this$1 = this;\n\n      var dir = 1, x = goalColumn\n      if (amount < 0) { dir = -1; amount = -amount }\n      var cur = clipPos(this.doc, from)\n      for (var i = 0; i < amount; ++i) {\n        var coords = cursorCoords(this$1, cur, \"div\")\n        if (x == null) { x = coords.left }\n        else { coords.left = x }\n        cur = findPosV(this$1, coords, dir, unit)\n        if (cur.hitSide) { break }\n      }\n      return cur\n    },\n\n    moveV: methodOp(function(dir, unit) {\n      var this$1 = this;\n\n      var doc = this.doc, goals = []\n      var collapse = !this.display.shift && !doc.extend && doc.sel.somethingSelected()\n      doc.extendSelectionsBy(function (range) {\n        if (collapse)\n          { return dir < 0 ? range.from() : range.to() }\n        var headPos = cursorCoords(this$1, range.head, \"div\")\n        if (range.goalColumn != null) { headPos.left = range.goalColumn }\n        goals.push(headPos.left)\n        var pos = findPosV(this$1, headPos, dir, unit)\n        if (unit == \"page\" && range == doc.sel.primary())\n          { addToScrollPos(this$1, null, charCoords(this$1, pos, \"div\").top - headPos.top) }\n        return pos\n      }, sel_move)\n      if (goals.length) { for (var i = 0; i < doc.sel.ranges.length; i++)\n        { doc.sel.ranges[i].goalColumn = goals[i] } }\n    }),\n\n    // Find the word at the given position (as returned by coordsChar).\n    findWordAt: function(pos) {\n      var doc = this.doc, line = getLine(doc, pos.line).text\n      var start = pos.ch, end = pos.ch\n      if (line) {\n        var helper = this.getHelper(pos, \"wordChars\")\n        if ((pos.sticky == \"before\" || end == line.length) && start) { --start; } else { ++end }\n        var startChar = line.charAt(start)\n        var check = isWordChar(startChar, helper)\n          ? function (ch) { return isWordChar(ch, helper); }\n          : /\\s/.test(startChar) ? function (ch) { return /\\s/.test(ch); }\n          : function (ch) { return (!/\\s/.test(ch) && !isWordChar(ch)); }\n        while (start > 0 && check(line.charAt(start - 1))) { --start }\n        while (end < line.length && check(line.charAt(end))) { ++end }\n      }\n      return new Range(Pos(pos.line, start), Pos(pos.line, end))\n    },\n\n    toggleOverwrite: function(value) {\n      if (value != null && value == this.state.overwrite) { return }\n      if (this.state.overwrite = !this.state.overwrite)\n        { addClass(this.display.cursorDiv, \"CodeMirror-overwrite\") }\n      else\n        { rmClass(this.display.cursorDiv, \"CodeMirror-overwrite\") }\n\n      signal(this, \"overwriteToggle\", this, this.state.overwrite)\n    },\n    hasFocus: function() { return this.display.input.getField() == activeElt() },\n    isReadOnly: function() { return !!(this.options.readOnly || this.doc.cantEdit) },\n\n    scrollTo: methodOp(function(x, y) {\n      if (x != null || y != null) { resolveScrollToPos(this) }\n      if (x != null) { this.curOp.scrollLeft = x }\n      if (y != null) { this.curOp.scrollTop = y }\n    }),\n    getScrollInfo: function() {\n      var scroller = this.display.scroller\n      return {left: scroller.scrollLeft, top: scroller.scrollTop,\n              height: scroller.scrollHeight - scrollGap(this) - this.display.barHeight,\n              width: scroller.scrollWidth - scrollGap(this) - this.display.barWidth,\n              clientHeight: displayHeight(this), clientWidth: displayWidth(this)}\n    },\n\n    scrollIntoView: methodOp(function(range, margin) {\n      if (range == null) {\n        range = {from: this.doc.sel.primary().head, to: null}\n        if (margin == null) { margin = this.options.cursorScrollMargin }\n      } else if (typeof range == \"number\") {\n        range = {from: Pos(range, 0), to: null}\n      } else if (range.from == null) {\n        range = {from: range, to: null}\n      }\n      if (!range.to) { range.to = range.from }\n      range.margin = margin || 0\n\n      if (range.from.line != null) {\n        resolveScrollToPos(this)\n        this.curOp.scrollToPos = range\n      } else {\n        var sPos = calculateScrollPos(this, Math.min(range.from.left, range.to.left),\n                                      Math.min(range.from.top, range.to.top) - range.margin,\n                                      Math.max(range.from.right, range.to.right),\n                                      Math.max(range.from.bottom, range.to.bottom) + range.margin)\n        this.scrollTo(sPos.scrollLeft, sPos.scrollTop)\n      }\n    }),\n\n    setSize: methodOp(function(width, height) {\n      var this$1 = this;\n\n      var interpret = function (val) { return typeof val == \"number\" || /^\\d+$/.test(String(val)) ? val + \"px\" : val; }\n      if (width != null) { this.display.wrapper.style.width = interpret(width) }\n      if (height != null) { this.display.wrapper.style.height = interpret(height) }\n      if (this.options.lineWrapping) { clearLineMeasurementCache(this) }\n      var lineNo = this.display.viewFrom\n      this.doc.iter(lineNo, this.display.viewTo, function (line) {\n        if (line.widgets) { for (var i = 0; i < line.widgets.length; i++)\n          { if (line.widgets[i].noHScroll) { regLineChange(this$1, lineNo, \"widget\"); break } } }\n        ++lineNo\n      })\n      this.curOp.forceUpdate = true\n      signal(this, \"refresh\", this)\n    }),\n\n    operation: function(f){return runInOp(this, f)},\n\n    refresh: methodOp(function() {\n      var oldHeight = this.display.cachedTextHeight\n      regChange(this)\n      this.curOp.forceUpdate = true\n      clearCaches(this)\n      this.scrollTo(this.doc.scrollLeft, this.doc.scrollTop)\n      updateGutterSpace(this)\n      if (oldHeight == null || Math.abs(oldHeight - textHeight(this.display)) > .5)\n        { estimateLineHeights(this) }\n      signal(this, \"refresh\", this)\n    }),\n\n    swapDoc: methodOp(function(doc) {\n      var old = this.doc\n      old.cm = null\n      attachDoc(this, doc)\n      clearCaches(this)\n      this.display.input.reset()\n      this.scrollTo(doc.scrollLeft, doc.scrollTop)\n      this.curOp.forceScroll = true\n      signalLater(this, \"swapDoc\", this, old)\n      return old\n    }),\n\n    getInputField: function(){return this.display.input.getField()},\n    getWrapperElement: function(){return this.display.wrapper},\n    getScrollerElement: function(){return this.display.scroller},\n    getGutterElement: function(){return this.display.gutters}\n  }\n  eventMixin(CodeMirror)\n\n  CodeMirror.registerHelper = function(type, name, value) {\n    if (!helpers.hasOwnProperty(type)) { helpers[type] = CodeMirror[type] = {_global: []} }\n    helpers[type][name] = value\n  }\n  CodeMirror.registerGlobalHelper = function(type, name, predicate, value) {\n    CodeMirror.registerHelper(type, name, value)\n    helpers[type]._global.push({pred: predicate, val: value})\n  }\n}\n\n// Used for horizontal relative motion. Dir is -1 or 1 (left or\n// right), unit can be \"char\", \"column\" (like char, but doesn't\n// cross line boundaries), \"word\" (across next word), or \"group\" (to\n// the start of next group of word or non-word-non-whitespace\n// chars). The visually param controls whether, in right-to-left\n// text, direction 1 means to move towards the next index in the\n// string, or towards the character to the right of the current\n// position. The resulting position will have a hitSide=true\n// property if it reached the end of the document.\nfunction findPosH(doc, pos, dir, unit, visually) {\n  var oldPos = pos\n  var origDir = dir\n  var lineObj = getLine(doc, pos.line)\n  function findNextLine() {\n    var l = pos.line + dir\n    if (l < doc.first || l >= doc.first + doc.size) { return false }\n    pos = new Pos(l, pos.ch, pos.sticky)\n    return lineObj = getLine(doc, l)\n  }\n  function moveOnce(boundToLine) {\n    var next\n    if (visually) {\n      next = moveVisually(doc.cm, lineObj, pos, dir)\n    } else {\n      next = moveLogically(lineObj, pos, dir)\n    }\n    if (next == null) {\n      if (!boundToLine && findNextLine())\n        { pos = endOfLine(visually, doc.cm, lineObj, pos.line, dir) }\n      else\n        { return false }\n    } else {\n      pos = next\n    }\n    return true\n  }\n\n  if (unit == \"char\") {\n    moveOnce()\n  } else if (unit == \"column\") {\n    moveOnce(true)\n  } else if (unit == \"word\" || unit == \"group\") {\n    var sawType = null, group = unit == \"group\"\n    var helper = doc.cm && doc.cm.getHelper(pos, \"wordChars\")\n    for (var first = true;; first = false) {\n      if (dir < 0 && !moveOnce(!first)) { break }\n      var cur = lineObj.text.charAt(pos.ch) || \"\\n\"\n      var type = isWordChar(cur, helper) ? \"w\"\n        : group && cur == \"\\n\" ? \"n\"\n        : !group || /\\s/.test(cur) ? null\n        : \"p\"\n      if (group && !first && !type) { type = \"s\" }\n      if (sawType && sawType != type) {\n        if (dir < 0) {dir = 1; moveOnce(); pos.sticky = \"after\"}\n        break\n      }\n\n      if (type) { sawType = type }\n      if (dir > 0 && !moveOnce(!first)) { break }\n    }\n  }\n  var result = skipAtomic(doc, pos, oldPos, origDir, true)\n  if (equalCursorPos(oldPos, result)) { result.hitSide = true }\n  return result\n}\n\n// For relative vertical movement. Dir may be -1 or 1. Unit can be\n// \"page\" or \"line\". The resulting position will have a hitSide=true\n// property if it reached the end of the document.\nfunction findPosV(cm, pos, dir, unit) {\n  var doc = cm.doc, x = pos.left, y\n  if (unit == \"page\") {\n    var pageSize = Math.min(cm.display.wrapper.clientHeight, window.innerHeight || document.documentElement.clientHeight)\n    var moveAmount = Math.max(pageSize - .5 * textHeight(cm.display), 3)\n    y = (dir > 0 ? pos.bottom : pos.top) + dir * moveAmount\n\n  } else if (unit == \"line\") {\n    y = dir > 0 ? pos.bottom + 3 : pos.top - 3\n  }\n  var target\n  for (;;) {\n    target = coordsChar(cm, x, y)\n    if (!target.outside) { break }\n    if (dir < 0 ? y <= 0 : y >= doc.height) { target.hitSide = true; break }\n    y += dir * 5\n  }\n  return target\n}\n\n// CONTENTEDITABLE INPUT STYLE\n\nvar ContentEditableInput = function(cm) {\n  this.cm = cm\n  this.lastAnchorNode = this.lastAnchorOffset = this.lastFocusNode = this.lastFocusOffset = null\n  this.polling = new Delayed()\n  this.composing = null\n  this.gracePeriod = false\n  this.readDOMTimeout = null\n};\n\nContentEditableInput.prototype.init = function (display) {\n    var this$1 = this;\n\n  var input = this, cm = input.cm\n  var div = input.div = display.lineDiv\n  disableBrowserMagic(div, cm.options.spellcheck)\n\n  on(div, \"paste\", function (e) {\n    if (signalDOMEvent(cm, e) || handlePaste(e, cm)) { return }\n    // IE doesn't fire input events, so we schedule a read for the pasted content in this way\n    if (ie_version <= 11) { setTimeout(operation(cm, function () {\n      if (!input.pollContent()) { regChange(cm) }\n    }), 20) }\n  })\n\n  on(div, \"compositionstart\", function (e) {\n    this$1.composing = {data: e.data, done: false}\n  })\n  on(div, \"compositionupdate\", function (e) {\n    if (!this$1.composing) { this$1.composing = {data: e.data, done: false} }\n  })\n  on(div, \"compositionend\", function (e) {\n    if (this$1.composing) {\n      if (e.data != this$1.composing.data) { this$1.readFromDOMSoon() }\n      this$1.composing.done = true\n    }\n  })\n\n  on(div, \"touchstart\", function () { return input.forceCompositionEnd(); })\n\n  on(div, \"input\", function () {\n    if (!this$1.composing) { this$1.readFromDOMSoon() }\n  })\n\n  function onCopyCut(e) {\n    if (signalDOMEvent(cm, e)) { return }\n    if (cm.somethingSelected()) {\n      setLastCopied({lineWise: false, text: cm.getSelections()})\n      if (e.type == \"cut\") { cm.replaceSelection(\"\", null, \"cut\") }\n    } else if (!cm.options.lineWiseCopyCut) {\n      return\n    } else {\n      var ranges = copyableRanges(cm)\n      setLastCopied({lineWise: true, text: ranges.text})\n      if (e.type == \"cut\") {\n        cm.operation(function () {\n          cm.setSelections(ranges.ranges, 0, sel_dontScroll)\n          cm.replaceSelection(\"\", null, \"cut\")\n        })\n      }\n    }\n    if (e.clipboardData) {\n      e.clipboardData.clearData()\n      var content = lastCopied.text.join(\"\\n\")\n      // iOS exposes the clipboard API, but seems to discard content inserted into it\n      e.clipboardData.setData(\"Text\", content)\n      if (e.clipboardData.getData(\"Text\") == content) {\n        e.preventDefault()\n        return\n      }\n    }\n    // Old-fashioned briefly-focus-a-textarea hack\n    var kludge = hiddenTextarea(), te = kludge.firstChild\n    cm.display.lineSpace.insertBefore(kludge, cm.display.lineSpace.firstChild)\n    te.value = lastCopied.text.join(\"\\n\")\n    var hadFocus = document.activeElement\n    selectInput(te)\n    setTimeout(function () {\n      cm.display.lineSpace.removeChild(kludge)\n      hadFocus.focus()\n      if (hadFocus == div) { input.showPrimarySelection() }\n    }, 50)\n  }\n  on(div, \"copy\", onCopyCut)\n  on(div, \"cut\", onCopyCut)\n};\n\nContentEditableInput.prototype.prepareSelection = function () {\n  var result = prepareSelection(this.cm, false)\n  result.focus = this.cm.state.focused\n  return result\n};\n\nContentEditableInput.prototype.showSelection = function (info, takeFocus) {\n  if (!info || !this.cm.display.view.length) { return }\n  if (info.focus || takeFocus) { this.showPrimarySelection() }\n  this.showMultipleSelections(info)\n};\n\nContentEditableInput.prototype.showPrimarySelection = function () {\n  var sel = window.getSelection(), prim = this.cm.doc.sel.primary()\n  var curAnchor = domToPos(this.cm, sel.anchorNode, sel.anchorOffset)\n  var curFocus = domToPos(this.cm, sel.focusNode, sel.focusOffset)\n  if (curAnchor && !curAnchor.bad && curFocus && !curFocus.bad &&\n      cmp(minPos(curAnchor, curFocus), prim.from()) == 0 &&\n      cmp(maxPos(curAnchor, curFocus), prim.to()) == 0)\n    { return }\n\n  var start = posToDOM(this.cm, prim.from())\n  var end = posToDOM(this.cm, prim.to())\n  if (!start && !end) { return }\n\n  var view = this.cm.display.view\n  var old = sel.rangeCount && sel.getRangeAt(0)\n  if (!start) {\n    start = {node: view[0].measure.map[2], offset: 0}\n  } else if (!end) { // FIXME dangerously hacky\n    var measure = view[view.length - 1].measure\n    var map = measure.maps ? measure.maps[measure.maps.length - 1] : measure.map\n    end = {node: map[map.length - 1], offset: map[map.length - 2] - map[map.length - 3]}\n  }\n\n  var rng\n  try { rng = range(start.node, start.offset, end.offset, end.node) }\n  catch(e) {} // Our model of the DOM might be outdated, in which case the range we try to set can be impossible\n  if (rng) {\n    if (!gecko && this.cm.state.focused) {\n      sel.collapse(start.node, start.offset)\n      if (!rng.collapsed) {\n        sel.removeAllRanges()\n        sel.addRange(rng)\n      }\n    } else {\n      sel.removeAllRanges()\n      sel.addRange(rng)\n    }\n    if (old && sel.anchorNode == null) { sel.addRange(old) }\n    else if (gecko) { this.startGracePeriod() }\n  }\n  this.rememberSelection()\n};\n\nContentEditableInput.prototype.startGracePeriod = function () {\n    var this$1 = this;\n\n  clearTimeout(this.gracePeriod)\n  this.gracePeriod = setTimeout(function () {\n    this$1.gracePeriod = false\n    if (this$1.selectionChanged())\n      { this$1.cm.operation(function () { return this$1.cm.curOp.selectionChanged = true; }) }\n  }, 20)\n};\n\nContentEditableInput.prototype.showMultipleSelections = function (info) {\n  removeChildrenAndAdd(this.cm.display.cursorDiv, info.cursors)\n  removeChildrenAndAdd(this.cm.display.selectionDiv, info.selection)\n};\n\nContentEditableInput.prototype.rememberSelection = function () {\n  var sel = window.getSelection()\n  this.lastAnchorNode = sel.anchorNode; this.lastAnchorOffset = sel.anchorOffset\n  this.lastFocusNode = sel.focusNode; this.lastFocusOffset = sel.focusOffset\n};\n\nContentEditableInput.prototype.selectionInEditor = function () {\n  var sel = window.getSelection()\n  if (!sel.rangeCount) { return false }\n  var node = sel.getRangeAt(0).commonAncestorContainer\n  return contains(this.div, node)\n};\n\nContentEditableInput.prototype.focus = function () {\n  if (this.cm.options.readOnly != \"nocursor\") {\n    if (!this.selectionInEditor())\n      { this.showSelection(this.prepareSelection(), true) }\n    this.div.focus()\n  }\n};\nContentEditableInput.prototype.blur = function () { this.div.blur() };\nContentEditableInput.prototype.getField = function () { return this.div };\n\nContentEditableInput.prototype.supportsTouch = function () { return true };\n\nContentEditableInput.prototype.receivedFocus = function () {\n  var input = this\n  if (this.selectionInEditor())\n    { this.pollSelection() }\n  else\n    { runInOp(this.cm, function () { return input.cm.curOp.selectionChanged = true; }) }\n\n  function poll() {\n    if (input.cm.state.focused) {\n      input.pollSelection()\n      input.polling.set(input.cm.options.pollInterval, poll)\n    }\n  }\n  this.polling.set(this.cm.options.pollInterval, poll)\n};\n\nContentEditableInput.prototype.selectionChanged = function () {\n  var sel = window.getSelection()\n  return sel.anchorNode != this.lastAnchorNode || sel.anchorOffset != this.lastAnchorOffset ||\n    sel.focusNode != this.lastFocusNode || sel.focusOffset != this.lastFocusOffset\n};\n\nContentEditableInput.prototype.pollSelection = function () {\n  if (!this.composing && this.readDOMTimeout == null && !this.gracePeriod && this.selectionChanged()) {\n    var sel = window.getSelection(), cm = this.cm\n    this.rememberSelection()\n    var anchor = domToPos(cm, sel.anchorNode, sel.anchorOffset)\n    var head = domToPos(cm, sel.focusNode, sel.focusOffset)\n    if (anchor && head) { runInOp(cm, function () {\n      setSelection(cm.doc, simpleSelection(anchor, head), sel_dontScroll)\n      if (anchor.bad || head.bad) { cm.curOp.selectionChanged = true }\n    }) }\n  }\n};\n\nContentEditableInput.prototype.pollContent = function () {\n  if (this.readDOMTimeout != null) {\n    clearTimeout(this.readDOMTimeout)\n    this.readDOMTimeout = null\n  }\n\n  var cm = this.cm, display = cm.display, sel = cm.doc.sel.primary()\n  var from = sel.from(), to = sel.to()\n  if (from.ch == 0 && from.line > cm.firstLine())\n    { from = Pos(from.line - 1, getLine(cm.doc, from.line - 1).length) }\n  if (to.ch == getLine(cm.doc, to.line).text.length && to.line < cm.lastLine())\n    { to = Pos(to.line + 1, 0) }\n  if (from.line < display.viewFrom || to.line > display.viewTo - 1) { return false }\n\n  var fromIndex, fromLine, fromNode\n  if (from.line == display.viewFrom || (fromIndex = findViewIndex(cm, from.line)) == 0) {\n    fromLine = lineNo(display.view[0].line)\n    fromNode = display.view[0].node\n  } else {\n    fromLine = lineNo(display.view[fromIndex].line)\n    fromNode = display.view[fromIndex - 1].node.nextSibling\n  }\n  var toIndex = findViewIndex(cm, to.line)\n  var toLine, toNode\n  if (toIndex == display.view.length - 1) {\n    toLine = display.viewTo - 1\n    toNode = display.lineDiv.lastChild\n  } else {\n    toLine = lineNo(display.view[toIndex + 1].line) - 1\n    toNode = display.view[toIndex + 1].node.previousSibling\n  }\n\n  if (!fromNode) { return false }\n  var newText = cm.doc.splitLines(domTextBetween(cm, fromNode, toNode, fromLine, toLine))\n  var oldText = getBetween(cm.doc, Pos(fromLine, 0), Pos(toLine, getLine(cm.doc, toLine).text.length))\n  while (newText.length > 1 && oldText.length > 1) {\n    if (lst(newText) == lst(oldText)) { newText.pop(); oldText.pop(); toLine-- }\n    else if (newText[0] == oldText[0]) { newText.shift(); oldText.shift(); fromLine++ }\n    else { break }\n  }\n\n  var cutFront = 0, cutEnd = 0\n  var newTop = newText[0], oldTop = oldText[0], maxCutFront = Math.min(newTop.length, oldTop.length)\n  while (cutFront < maxCutFront && newTop.charCodeAt(cutFront) == oldTop.charCodeAt(cutFront))\n    { ++cutFront }\n  var newBot = lst(newText), oldBot = lst(oldText)\n  var maxCutEnd = Math.min(newBot.length - (newText.length == 1 ? cutFront : 0),\n                           oldBot.length - (oldText.length == 1 ? cutFront : 0))\n  while (cutEnd < maxCutEnd &&\n         newBot.charCodeAt(newBot.length - cutEnd - 1) == oldBot.charCodeAt(oldBot.length - cutEnd - 1))\n    { ++cutEnd }\n\n  newText[newText.length - 1] = newBot.slice(0, newBot.length - cutEnd).replace(/^\\u200b+/, \"\")\n  newText[0] = newText[0].slice(cutFront).replace(/\\u200b+$/, \"\")\n\n  var chFrom = Pos(fromLine, cutFront)\n  var chTo = Pos(toLine, oldText.length ? lst(oldText).length - cutEnd : 0)\n  if (newText.length > 1 || newText[0] || cmp(chFrom, chTo)) {\n    replaceRange(cm.doc, newText, chFrom, chTo, \"+input\")\n    return true\n  }\n};\n\nContentEditableInput.prototype.ensurePolled = function () {\n  this.forceCompositionEnd()\n};\nContentEditableInput.prototype.reset = function () {\n  this.forceCompositionEnd()\n};\nContentEditableInput.prototype.forceCompositionEnd = function () {\n  if (!this.composing) { return }\n  clearTimeout(this.readDOMTimeout)\n  this.composing = null\n  if (!this.pollContent()) { regChange(this.cm) }\n  this.div.blur()\n  this.div.focus()\n};\nContentEditableInput.prototype.readFromDOMSoon = function () {\n    var this$1 = this;\n\n  if (this.readDOMTimeout != null) { return }\n  this.readDOMTimeout = setTimeout(function () {\n    this$1.readDOMTimeout = null\n    if (this$1.composing) {\n      if (this$1.composing.done) { this$1.composing = null }\n      else { return }\n    }\n    if (this$1.cm.isReadOnly() || !this$1.pollContent())\n      { runInOp(this$1.cm, function () { return regChange(this$1.cm); }) }\n  }, 80)\n};\n\nContentEditableInput.prototype.setUneditable = function (node) {\n  node.contentEditable = \"false\"\n};\n\nContentEditableInput.prototype.onKeyPress = function (e) {\n  if (e.charCode == 0) { return }\n  e.preventDefault()\n  if (!this.cm.isReadOnly())\n    { operation(this.cm, applyTextInput)(this.cm, String.fromCharCode(e.charCode == null ? e.keyCode : e.charCode), 0) }\n};\n\nContentEditableInput.prototype.readOnlyChanged = function (val) {\n  this.div.contentEditable = String(val != \"nocursor\")\n};\n\nContentEditableInput.prototype.onContextMenu = function () {};\nContentEditableInput.prototype.resetPosition = function () {};\n\nContentEditableInput.prototype.needsContentAttribute = true\n\nfunction posToDOM(cm, pos) {\n  var view = findViewForLine(cm, pos.line)\n  if (!view || view.hidden) { return null }\n  var line = getLine(cm.doc, pos.line)\n  var info = mapFromLineView(view, line, pos.line)\n\n  var order = getOrder(line), side = \"left\"\n  if (order) {\n    var partPos = getBidiPartAt(order, pos.ch)\n    side = partPos % 2 ? \"right\" : \"left\"\n  }\n  var result = nodeAndOffsetInLineMap(info.map, pos.ch, side)\n  result.offset = result.collapse == \"right\" ? result.end : result.start\n  return result\n}\n\nfunction badPos(pos, bad) { if (bad) { pos.bad = true; } return pos }\n\nfunction domTextBetween(cm, from, to, fromLine, toLine) {\n  var text = \"\", closing = false, lineSep = cm.doc.lineSeparator()\n  function recognizeMarker(id) { return function (marker) { return marker.id == id; } }\n  function walk(node) {\n    if (node.nodeType == 1) {\n      var cmText = node.getAttribute(\"cm-text\")\n      if (cmText != null) {\n        if (cmText == \"\") { text += node.textContent.replace(/\\u200b/g, \"\") }\n        else { text += cmText }\n        return\n      }\n      var markerID = node.getAttribute(\"cm-marker\"), range\n      if (markerID) {\n        var found = cm.findMarks(Pos(fromLine, 0), Pos(toLine + 1, 0), recognizeMarker(+markerID))\n        if (found.length && (range = found[0].find()))\n          { text += getBetween(cm.doc, range.from, range.to).join(lineSep) }\n        return\n      }\n      if (node.getAttribute(\"contenteditable\") == \"false\") { return }\n      for (var i = 0; i < node.childNodes.length; i++)\n        { walk(node.childNodes[i]) }\n      if (/^(pre|div|p)$/i.test(node.nodeName))\n        { closing = true }\n    } else if (node.nodeType == 3) {\n      var val = node.nodeValue\n      if (!val) { return }\n      if (closing) {\n        text += lineSep\n        closing = false\n      }\n      text += val\n    }\n  }\n  for (;;) {\n    walk(from)\n    if (from == to) { break }\n    from = from.nextSibling\n  }\n  return text\n}\n\nfunction domToPos(cm, node, offset) {\n  var lineNode\n  if (node == cm.display.lineDiv) {\n    lineNode = cm.display.lineDiv.childNodes[offset]\n    if (!lineNode) { return badPos(cm.clipPos(Pos(cm.display.viewTo - 1)), true) }\n    node = null; offset = 0\n  } else {\n    for (lineNode = node;; lineNode = lineNode.parentNode) {\n      if (!lineNode || lineNode == cm.display.lineDiv) { return null }\n      if (lineNode.parentNode && lineNode.parentNode == cm.display.lineDiv) { break }\n    }\n  }\n  for (var i = 0; i < cm.display.view.length; i++) {\n    var lineView = cm.display.view[i]\n    if (lineView.node == lineNode)\n      { return locateNodeInLineView(lineView, node, offset) }\n  }\n}\n\nfunction locateNodeInLineView(lineView, node, offset) {\n  var wrapper = lineView.text.firstChild, bad = false\n  if (!node || !contains(wrapper, node)) { return badPos(Pos(lineNo(lineView.line), 0), true) }\n  if (node == wrapper) {\n    bad = true\n    node = wrapper.childNodes[offset]\n    offset = 0\n    if (!node) {\n      var line = lineView.rest ? lst(lineView.rest) : lineView.line\n      return badPos(Pos(lineNo(line), line.text.length), bad)\n    }\n  }\n\n  var textNode = node.nodeType == 3 ? node : null, topNode = node\n  if (!textNode && node.childNodes.length == 1 && node.firstChild.nodeType == 3) {\n    textNode = node.firstChild\n    if (offset) { offset = textNode.nodeValue.length }\n  }\n  while (topNode.parentNode != wrapper) { topNode = topNode.parentNode }\n  var measure = lineView.measure, maps = measure.maps\n\n  function find(textNode, topNode, offset) {\n    for (var i = -1; i < (maps ? maps.length : 0); i++) {\n      var map = i < 0 ? measure.map : maps[i]\n      for (var j = 0; j < map.length; j += 3) {\n        var curNode = map[j + 2]\n        if (curNode == textNode || curNode == topNode) {\n          var line = lineNo(i < 0 ? lineView.line : lineView.rest[i])\n          var ch = map[j] + offset\n          if (offset < 0 || curNode != textNode) { ch = map[j + (offset ? 1 : 0)] }\n          return Pos(line, ch)\n        }\n      }\n    }\n  }\n  var found = find(textNode, topNode, offset)\n  if (found) { return badPos(found, bad) }\n\n  // FIXME this is all really shaky. might handle the few cases it needs to handle, but likely to cause problems\n  for (var after = topNode.nextSibling, dist = textNode ? textNode.nodeValue.length - offset : 0; after; after = after.nextSibling) {\n    found = find(after, after.firstChild, 0)\n    if (found)\n      { return badPos(Pos(found.line, found.ch - dist), bad) }\n    else\n      { dist += after.textContent.length }\n  }\n  for (var before = topNode.previousSibling, dist$1 = offset; before; before = before.previousSibling) {\n    found = find(before, before.firstChild, -1)\n    if (found)\n      { return badPos(Pos(found.line, found.ch + dist$1), bad) }\n    else\n      { dist$1 += before.textContent.length }\n  }\n}\n\n// TEXTAREA INPUT STYLE\n\nvar TextareaInput = function(cm) {\n  this.cm = cm\n  // See input.poll and input.reset\n  this.prevInput = \"\"\n\n  // Flag that indicates whether we expect input to appear real soon\n  // now (after some event like 'keypress' or 'input') and are\n  // polling intensively.\n  this.pollingFast = false\n  // Self-resetting timeout for the poller\n  this.polling = new Delayed()\n  // Tracks when input.reset has punted to just putting a short\n  // string into the textarea instead of the full selection.\n  this.inaccurateSelection = false\n  // Used to work around IE issue with selection being forgotten when focus moves away from textarea\n  this.hasSelection = false\n  this.composing = null\n};\n\nTextareaInput.prototype.init = function (display) {\n    var this$1 = this;\n\n  var input = this, cm = this.cm\n\n  // Wraps and hides input textarea\n  var div = this.wrapper = hiddenTextarea()\n  // The semihidden textarea that is focused when the editor is\n  // focused, and receives input.\n  var te = this.textarea = div.firstChild\n  display.wrapper.insertBefore(div, display.wrapper.firstChild)\n\n  // Needed to hide big blue blinking cursor on Mobile Safari (doesn't seem to work in iOS 8 anymore)\n  if (ios) { te.style.width = \"0px\" }\n\n  on(te, \"input\", function () {\n    if (ie && ie_version >= 9 && this$1.hasSelection) { this$1.hasSelection = null }\n    input.poll()\n  })\n\n  on(te, \"paste\", function (e) {\n    if (signalDOMEvent(cm, e) || handlePaste(e, cm)) { return }\n\n    cm.state.pasteIncoming = true\n    input.fastPoll()\n  })\n\n  function prepareCopyCut(e) {\n    if (signalDOMEvent(cm, e)) { return }\n    if (cm.somethingSelected()) {\n      setLastCopied({lineWise: false, text: cm.getSelections()})\n      if (input.inaccurateSelection) {\n        input.prevInput = \"\"\n        input.inaccurateSelection = false\n        te.value = lastCopied.text.join(\"\\n\")\n        selectInput(te)\n      }\n    } else if (!cm.options.lineWiseCopyCut) {\n      return\n    } else {\n      var ranges = copyableRanges(cm)\n      setLastCopied({lineWise: true, text: ranges.text})\n      if (e.type == \"cut\") {\n        cm.setSelections(ranges.ranges, null, sel_dontScroll)\n      } else {\n        input.prevInput = \"\"\n        te.value = ranges.text.join(\"\\n\")\n        selectInput(te)\n      }\n    }\n    if (e.type == \"cut\") { cm.state.cutIncoming = true }\n  }\n  on(te, \"cut\", prepareCopyCut)\n  on(te, \"copy\", prepareCopyCut)\n\n  on(display.scroller, \"paste\", function (e) {\n    if (eventInWidget(display, e) || signalDOMEvent(cm, e)) { return }\n    cm.state.pasteIncoming = true\n    input.focus()\n  })\n\n  // Prevent normal selection in the editor (we handle our own)\n  on(display.lineSpace, \"selectstart\", function (e) {\n    if (!eventInWidget(display, e)) { e_preventDefault(e) }\n  })\n\n  on(te, \"compositionstart\", function () {\n    var start = cm.getCursor(\"from\")\n    if (input.composing) { input.composing.range.clear() }\n    input.composing = {\n      start: start,\n      range: cm.markText(start, cm.getCursor(\"to\"), {className: \"CodeMirror-composing\"})\n    }\n  })\n  on(te, \"compositionend\", function () {\n    if (input.composing) {\n      input.poll()\n      input.composing.range.clear()\n      input.composing = null\n    }\n  })\n};\n\nTextareaInput.prototype.prepareSelection = function () {\n  // Redraw the selection and/or cursor\n  var cm = this.cm, display = cm.display, doc = cm.doc\n  var result = prepareSelection(cm)\n\n  // Move the hidden textarea near the cursor to prevent scrolling artifacts\n  if (cm.options.moveInputWithCursor) {\n    var headPos = cursorCoords(cm, doc.sel.primary().head, \"div\")\n    var wrapOff = display.wrapper.getBoundingClientRect(), lineOff = display.lineDiv.getBoundingClientRect()\n    result.teTop = Math.max(0, Math.min(display.wrapper.clientHeight - 10,\n                                        headPos.top + lineOff.top - wrapOff.top))\n    result.teLeft = Math.max(0, Math.min(display.wrapper.clientWidth - 10,\n                                         headPos.left + lineOff.left - wrapOff.left))\n  }\n\n  return result\n};\n\nTextareaInput.prototype.showSelection = function (drawn) {\n  var cm = this.cm, display = cm.display\n  removeChildrenAndAdd(display.cursorDiv, drawn.cursors)\n  removeChildrenAndAdd(display.selectionDiv, drawn.selection)\n  if (drawn.teTop != null) {\n    this.wrapper.style.top = drawn.teTop + \"px\"\n    this.wrapper.style.left = drawn.teLeft + \"px\"\n  }\n};\n\n// Reset the input to correspond to the selection (or to be empty,\n// when not typing and nothing is selected)\nTextareaInput.prototype.reset = function (typing) {\n  if (this.contextMenuPending) { return }\n  var minimal, selected, cm = this.cm, doc = cm.doc\n  if (cm.somethingSelected()) {\n    this.prevInput = \"\"\n    var range = doc.sel.primary()\n    minimal = hasCopyEvent &&\n      (range.to().line - range.from().line > 100 || (selected = cm.getSelection()).length > 1000)\n    var content = minimal ? \"-\" : selected || cm.getSelection()\n    this.textarea.value = content\n    if (cm.state.focused) { selectInput(this.textarea) }\n    if (ie && ie_version >= 9) { this.hasSelection = content }\n  } else if (!typing) {\n    this.prevInput = this.textarea.value = \"\"\n    if (ie && ie_version >= 9) { this.hasSelection = null }\n  }\n  this.inaccurateSelection = minimal\n};\n\nTextareaInput.prototype.getField = function () { return this.textarea };\n\nTextareaInput.prototype.supportsTouch = function () { return false };\n\nTextareaInput.prototype.focus = function () {\n  if (this.cm.options.readOnly != \"nocursor\" && (!mobile || activeElt() != this.textarea)) {\n    try { this.textarea.focus() }\n    catch (e) {} // IE8 will throw if the textarea is display: none or not in DOM\n  }\n};\n\nTextareaInput.prototype.blur = function () { this.textarea.blur() };\n\nTextareaInput.prototype.resetPosition = function () {\n  this.wrapper.style.top = this.wrapper.style.left = 0\n};\n\nTextareaInput.prototype.receivedFocus = function () { this.slowPoll() };\n\n// Poll for input changes, using the normal rate of polling. This\n// runs as long as the editor is focused.\nTextareaInput.prototype.slowPoll = function () {\n    var this$1 = this;\n\n  if (this.pollingFast) { return }\n  this.polling.set(this.cm.options.pollInterval, function () {\n    this$1.poll()\n    if (this$1.cm.state.focused) { this$1.slowPoll() }\n  })\n};\n\n// When an event has just come in that is likely to add or change\n// something in the input textarea, we poll faster, to ensure that\n// the change appears on the screen quickly.\nTextareaInput.prototype.fastPoll = function () {\n  var missed = false, input = this\n  input.pollingFast = true\n  function p() {\n    var changed = input.poll()\n    if (!changed && !missed) {missed = true; input.polling.set(60, p)}\n    else {input.pollingFast = false; input.slowPoll()}\n  }\n  input.polling.set(20, p)\n};\n\n// Read input from the textarea, and update the document to match.\n// When something is selected, it is present in the textarea, and\n// selected (unless it is huge, in which case a placeholder is\n// used). When nothing is selected, the cursor sits after previously\n// seen text (can be empty), which is stored in prevInput (we must\n// not reset the textarea when typing, because that breaks IME).\nTextareaInput.prototype.poll = function () {\n    var this$1 = this;\n\n  var cm = this.cm, input = this.textarea, prevInput = this.prevInput\n  // Since this is called a *lot*, try to bail out as cheaply as\n  // possible when it is clear that nothing happened. hasSelection\n  // will be the case when there is a lot of text in the textarea,\n  // in which case reading its value would be expensive.\n  if (this.contextMenuPending || !cm.state.focused ||\n      (hasSelection(input) && !prevInput && !this.composing) ||\n      cm.isReadOnly() || cm.options.disableInput || cm.state.keySeq)\n    { return false }\n\n  var text = input.value\n  // If nothing changed, bail.\n  if (text == prevInput && !cm.somethingSelected()) { return false }\n  // Work around nonsensical selection resetting in IE9/10, and\n  // inexplicable appearance of private area unicode characters on\n  // some key combos in Mac (#2689).\n  if (ie && ie_version >= 9 && this.hasSelection === text ||\n      mac && /[\\uf700-\\uf7ff]/.test(text)) {\n    cm.display.input.reset()\n    return false\n  }\n\n  if (cm.doc.sel == cm.display.selForContextMenu) {\n    var first = text.charCodeAt(0)\n    if (first == 0x200b && !prevInput) { prevInput = \"\\u200b\" }\n    if (first == 0x21da) { this.reset(); return this.cm.execCommand(\"undo\") }\n  }\n  // Find the part of the input that is actually new\n  var same = 0, l = Math.min(prevInput.length, text.length)\n  while (same < l && prevInput.charCodeAt(same) == text.charCodeAt(same)) { ++same }\n\n  runInOp(cm, function () {\n    applyTextInput(cm, text.slice(same), prevInput.length - same,\n                   null, this$1.composing ? \"*compose\" : null)\n\n    // Don't leave long text in the textarea, since it makes further polling slow\n    if (text.length > 1000 || text.indexOf(\"\\n\") > -1) { input.value = this$1.prevInput = \"\" }\n    else { this$1.prevInput = text }\n\n    if (this$1.composing) {\n      this$1.composing.range.clear()\n      this$1.composing.range = cm.markText(this$1.composing.start, cm.getCursor(\"to\"),\n                                         {className: \"CodeMirror-composing\"})\n    }\n  })\n  return true\n};\n\nTextareaInput.prototype.ensurePolled = function () {\n  if (this.pollingFast && this.poll()) { this.pollingFast = false }\n};\n\nTextareaInput.prototype.onKeyPress = function () {\n  if (ie && ie_version >= 9) { this.hasSelection = null }\n  this.fastPoll()\n};\n\nTextareaInput.prototype.onContextMenu = function (e) {\n  var input = this, cm = input.cm, display = cm.display, te = input.textarea\n  var pos = posFromMouse(cm, e), scrollPos = display.scroller.scrollTop\n  if (!pos || presto) { return } // Opera is difficult.\n\n  // Reset the current text selection only if the click is done outside of the selection\n  // and 'resetSelectionOnContextMenu' option is true.\n  var reset = cm.options.resetSelectionOnContextMenu\n  if (reset && cm.doc.sel.contains(pos) == -1)\n    { operation(cm, setSelection)(cm.doc, simpleSelection(pos), sel_dontScroll) }\n\n  var oldCSS = te.style.cssText, oldWrapperCSS = input.wrapper.style.cssText\n  input.wrapper.style.cssText = \"position: absolute\"\n  var wrapperBox = input.wrapper.getBoundingClientRect()\n  te.style.cssText = \"position: absolute; width: 30px; height: 30px;\\n      top: \" + (e.clientY - wrapperBox.top - 5) + \"px; left: \" + (e.clientX - wrapperBox.left - 5) + \"px;\\n      z-index: 1000; background: \" + (ie ? \"rgba(255, 255, 255, .05)\" : \"transparent\") + \";\\n      outline: none; border-width: 0; outline: none; overflow: hidden; opacity: .05; filter: alpha(opacity=5);\"\n  var oldScrollY\n  if (webkit) { oldScrollY = window.scrollY } // Work around Chrome issue (#2712)\n  display.input.focus()\n  if (webkit) { window.scrollTo(null, oldScrollY) }\n  display.input.reset()\n  // Adds \"Select all\" to context menu in FF\n  if (!cm.somethingSelected()) { te.value = input.prevInput = \" \" }\n  input.contextMenuPending = true\n  display.selForContextMenu = cm.doc.sel\n  clearTimeout(display.detectingSelectAll)\n\n  // Select-all will be greyed out if there's nothing to select, so\n  // this adds a zero-width space so that we can later check whether\n  // it got selected.\n  function prepareSelectAllHack() {\n    if (te.selectionStart != null) {\n      var selected = cm.somethingSelected()\n      var extval = \"\\u200b\" + (selected ? te.value : \"\")\n      te.value = \"\\u21da\" // Used to catch context-menu undo\n      te.value = extval\n      input.prevInput = selected ? \"\" : \"\\u200b\"\n      te.selectionStart = 1; te.selectionEnd = extval.length\n      // Re-set this, in case some other handler touched the\n      // selection in the meantime.\n      display.selForContextMenu = cm.doc.sel\n    }\n  }\n  function rehide() {\n    input.contextMenuPending = false\n    input.wrapper.style.cssText = oldWrapperCSS\n    te.style.cssText = oldCSS\n    if (ie && ie_version < 9) { display.scrollbars.setScrollTop(display.scroller.scrollTop = scrollPos) }\n\n    // Try to detect the user choosing select-all\n    if (te.selectionStart != null) {\n      if (!ie || (ie && ie_version < 9)) { prepareSelectAllHack() }\n      var i = 0, poll = function () {\n        if (display.selForContextMenu == cm.doc.sel && te.selectionStart == 0 &&\n            te.selectionEnd > 0 && input.prevInput == \"\\u200b\") {\n          operation(cm, selectAll)(cm)\n        } else if (i++ < 10) {\n          display.detectingSelectAll = setTimeout(poll, 500)\n        } else {\n          display.selForContextMenu = null\n          display.input.reset()\n        }\n      }\n      display.detectingSelectAll = setTimeout(poll, 200)\n    }\n  }\n\n  if (ie && ie_version >= 9) { prepareSelectAllHack() }\n  if (captureRightClick) {\n    e_stop(e)\n    var mouseup = function () {\n      off(window, \"mouseup\", mouseup)\n      setTimeout(rehide, 20)\n    }\n    on(window, \"mouseup\", mouseup)\n  } else {\n    setTimeout(rehide, 50)\n  }\n};\n\nTextareaInput.prototype.readOnlyChanged = function (val) {\n  if (!val) { this.reset() }\n};\n\nTextareaInput.prototype.setUneditable = function () {};\n\nTextareaInput.prototype.needsContentAttribute = false\n\nfunction fromTextArea(textarea, options) {\n  options = options ? copyObj(options) : {}\n  options.value = textarea.value\n  if (!options.tabindex && textarea.tabIndex)\n    { options.tabindex = textarea.tabIndex }\n  if (!options.placeholder && textarea.placeholder)\n    { options.placeholder = textarea.placeholder }\n  // Set autofocus to true if this textarea is focused, or if it has\n  // autofocus and no other element is focused.\n  if (options.autofocus == null) {\n    var hasFocus = activeElt()\n    options.autofocus = hasFocus == textarea ||\n      textarea.getAttribute(\"autofocus\") != null && hasFocus == document.body\n  }\n\n  function save() {textarea.value = cm.getValue()}\n\n  var realSubmit\n  if (textarea.form) {\n    on(textarea.form, \"submit\", save)\n    // Deplorable hack to make the submit method do the right thing.\n    if (!options.leaveSubmitMethodAlone) {\n      var form = textarea.form\n      realSubmit = form.submit\n      try {\n        var wrappedSubmit = form.submit = function () {\n          save()\n          form.submit = realSubmit\n          form.submit()\n          form.submit = wrappedSubmit\n        }\n      } catch(e) {}\n    }\n  }\n\n  options.finishInit = function (cm) {\n    cm.save = save\n    cm.getTextArea = function () { return textarea; }\n    cm.toTextArea = function () {\n      cm.toTextArea = isNaN // Prevent this from being ran twice\n      save()\n      textarea.parentNode.removeChild(cm.getWrapperElement())\n      textarea.style.display = \"\"\n      if (textarea.form) {\n        off(textarea.form, \"submit\", save)\n        if (typeof textarea.form.submit == \"function\")\n          { textarea.form.submit = realSubmit }\n      }\n    }\n  }\n\n  textarea.style.display = \"none\"\n  var cm = CodeMirror(function (node) { return textarea.parentNode.insertBefore(node, textarea.nextSibling); },\n    options)\n  return cm\n}\n\nfunction addLegacyProps(CodeMirror) {\n  CodeMirror.off = off\n  CodeMirror.on = on\n  CodeMirror.wheelEventPixels = wheelEventPixels\n  CodeMirror.Doc = Doc\n  CodeMirror.splitLines = splitLinesAuto\n  CodeMirror.countColumn = countColumn\n  CodeMirror.findColumn = findColumn\n  CodeMirror.isWordChar = isWordCharBasic\n  CodeMirror.Pass = Pass\n  CodeMirror.signal = signal\n  CodeMirror.Line = Line\n  CodeMirror.changeEnd = changeEnd\n  CodeMirror.scrollbarModel = scrollbarModel\n  CodeMirror.Pos = Pos\n  CodeMirror.cmpPos = cmp\n  CodeMirror.modes = modes\n  CodeMirror.mimeModes = mimeModes\n  CodeMirror.resolveMode = resolveMode\n  CodeMirror.getMode = getMode\n  CodeMirror.modeExtensions = modeExtensions\n  CodeMirror.extendMode = extendMode\n  CodeMirror.copyState = copyState\n  CodeMirror.startState = startState\n  CodeMirror.innerMode = innerMode\n  CodeMirror.commands = commands\n  CodeMirror.keyMap = keyMap\n  CodeMirror.keyName = keyName\n  CodeMirror.isModifierKey = isModifierKey\n  CodeMirror.lookupKey = lookupKey\n  CodeMirror.normalizeKeyMap = normalizeKeyMap\n  CodeMirror.StringStream = StringStream\n  CodeMirror.SharedTextMarker = SharedTextMarker\n  CodeMirror.TextMarker = TextMarker\n  CodeMirror.LineWidget = LineWidget\n  CodeMirror.e_preventDefault = e_preventDefault\n  CodeMirror.e_stopPropagation = e_stopPropagation\n  CodeMirror.e_stop = e_stop\n  CodeMirror.addClass = addClass\n  CodeMirror.contains = contains\n  CodeMirror.rmClass = rmClass\n  CodeMirror.keyNames = keyNames\n}\n\n// EDITOR CONSTRUCTOR\n\ndefineOptions(CodeMirror)\n\naddEditorMethods(CodeMirror)\n\n// Set up methods on CodeMirror's prototype to redirect to the editor's document.\nvar dontDelegate = \"iter insert remove copy getEditor constructor\".split(\" \")\nfor (var prop in Doc.prototype) { if (Doc.prototype.hasOwnProperty(prop) && indexOf(dontDelegate, prop) < 0)\n  { CodeMirror.prototype[prop] = (function(method) {\n    return function() {return method.apply(this.doc, arguments)}\n  })(Doc.prototype[prop]) } }\n\neventMixin(Doc)\n\n// INPUT HANDLING\n\nCodeMirror.inputStyles = {\"textarea\": TextareaInput, \"contenteditable\": ContentEditableInput}\n\n// MODE DEFINITION AND QUERYING\n\n// Extra arguments are stored as the mode's dependencies, which is\n// used by (legacy) mechanisms like loadmode.js to automatically\n// load a mode. (Preferred mechanism is the require/define calls.)\nCodeMirror.defineMode = function(name/*, mode, …*/) {\n  if (!CodeMirror.defaults.mode && name != \"null\") { CodeMirror.defaults.mode = name }\n  defineMode.apply(this, arguments)\n}\n\nCodeMirror.defineMIME = defineMIME\n\n// Minimal default mode.\nCodeMirror.defineMode(\"null\", function () { return ({token: function (stream) { return stream.skipToEnd(); }}); })\nCodeMirror.defineMIME(\"text/plain\", \"null\")\n\n// EXTENSIONS\n\nCodeMirror.defineExtension = function (name, func) {\n  CodeMirror.prototype[name] = func\n}\nCodeMirror.defineDocExtension = function (name, func) {\n  Doc.prototype[name] = func\n}\n\nCodeMirror.fromTextArea = fromTextArea\n\naddLegacyProps(CodeMirror)\n\nCodeMirror.version = \"5.24.2\"\n\nreturn CodeMirror;\n\n})));\n\n\n//////////////////\n// WEBPACK FOOTER\n// ../~/codemirror/lib/codemirror.js\n// module id = 592\n// module chunks = 4","// CodeMirror, copyright (c) by Marijn Haverbeke and others\n// Distributed under an MIT license: http://codemirror.net/LICENSE\n\n(function(mod) {\n  if (typeof exports == \"object\" && typeof module == \"object\") // CommonJS\n    mod(require(\"../../lib/codemirror\"));\n  else if (typeof define == \"function\" && define.amd) // AMD\n    define([\"../../lib/codemirror\"], mod);\n  else // Plain browser env\n    mod(CodeMirror);\n})(function(CodeMirror) {\n  var ie_lt8 = /MSIE \\d/.test(navigator.userAgent) &&\n    (document.documentMode == null || document.documentMode < 8);\n\n  var Pos = CodeMirror.Pos;\n\n  var matching = {\"(\": \")>\", \")\": \"(<\", \"[\": \"]>\", \"]\": \"[<\", \"{\": \"}>\", \"}\": \"{<\"};\n\n  function findMatchingBracket(cm, where, strict, config) {\n    var line = cm.getLineHandle(where.line), pos = where.ch - 1;\n    var match = (pos >= 0 && matching[line.text.charAt(pos)]) || matching[line.text.charAt(++pos)];\n    if (!match) return null;\n    var dir = match.charAt(1) == \">\" ? 1 : -1;\n    if (strict && (dir > 0) != (pos == where.ch)) return null;\n    var style = cm.getTokenTypeAt(Pos(where.line, pos + 1));\n\n    var found = scanForBracket(cm, Pos(where.line, pos + (dir > 0 ? 1 : 0)), dir, style || null, config);\n    if (found == null) return null;\n    return {from: Pos(where.line, pos), to: found && found.pos,\n            match: found && found.ch == match.charAt(0), forward: dir > 0};\n  }\n\n  // bracketRegex is used to specify which type of bracket to scan\n  // should be a regexp, e.g. /[[\\]]/\n  //\n  // Note: If \"where\" is on an open bracket, then this bracket is ignored.\n  //\n  // Returns false when no bracket was found, null when it reached\n  // maxScanLines and gave up\n  function scanForBracket(cm, where, dir, style, config) {\n    var maxScanLen = (config && config.maxScanLineLength) || 10000;\n    var maxScanLines = (config && config.maxScanLines) || 1000;\n\n    var stack = [];\n    var re = config && config.bracketRegex ? config.bracketRegex : /[(){}[\\]]/;\n    var lineEnd = dir > 0 ? Math.min(where.line + maxScanLines, cm.lastLine() + 1)\n                          : Math.max(cm.firstLine() - 1, where.line - maxScanLines);\n    for (var lineNo = where.line; lineNo != lineEnd; lineNo += dir) {\n      var line = cm.getLine(lineNo);\n      if (!line) continue;\n      var pos = dir > 0 ? 0 : line.length - 1, end = dir > 0 ? line.length : -1;\n      if (line.length > maxScanLen) continue;\n      if (lineNo == where.line) pos = where.ch - (dir < 0 ? 1 : 0);\n      for (; pos != end; pos += dir) {\n        var ch = line.charAt(pos);\n        if (re.test(ch) && (style === undefined || cm.getTokenTypeAt(Pos(lineNo, pos + 1)) == style)) {\n          var match = matching[ch];\n          if ((match.charAt(1) == \">\") == (dir > 0)) stack.push(ch);\n          else if (!stack.length) return {pos: Pos(lineNo, pos), ch: ch};\n          else stack.pop();\n        }\n      }\n    }\n    return lineNo - dir == (dir > 0 ? cm.lastLine() : cm.firstLine()) ? false : null;\n  }\n\n  function matchBrackets(cm, autoclear, config) {\n    // Disable brace matching in long lines, since it'll cause hugely slow updates\n    var maxHighlightLen = cm.state.matchBrackets.maxHighlightLineLength || 1000;\n    var marks = [], ranges = cm.listSelections();\n    for (var i = 0; i < ranges.length; i++) {\n      var match = ranges[i].empty() && findMatchingBracket(cm, ranges[i].head, false, config);\n      if (match && cm.getLine(match.from.line).length <= maxHighlightLen) {\n        var style = match.match ? \"CodeMirror-matchingbracket\" : \"CodeMirror-nonmatchingbracket\";\n        marks.push(cm.markText(match.from, Pos(match.from.line, match.from.ch + 1), {className: style}));\n        if (match.to && cm.getLine(match.to.line).length <= maxHighlightLen)\n          marks.push(cm.markText(match.to, Pos(match.to.line, match.to.ch + 1), {className: style}));\n      }\n    }\n\n    if (marks.length) {\n      // Kludge to work around the IE bug from issue #1193, where text\n      // input stops going to the textare whever this fires.\n      if (ie_lt8 && cm.state.focused) cm.focus();\n\n      var clear = function() {\n        cm.operation(function() {\n          for (var i = 0; i < marks.length; i++) marks[i].clear();\n        });\n      };\n      if (autoclear) setTimeout(clear, 800);\n      else return clear;\n    }\n  }\n\n  var currentlyHighlighted = null;\n  function doMatchBrackets(cm) {\n    cm.operation(function() {\n      if (currentlyHighlighted) {currentlyHighlighted(); currentlyHighlighted = null;}\n      currentlyHighlighted = matchBrackets(cm, false, cm.state.matchBrackets);\n    });\n  }\n\n  CodeMirror.defineOption(\"matchBrackets\", false, function(cm, val, old) {\n    if (old && old != CodeMirror.Init) {\n      cm.off(\"cursorActivity\", doMatchBrackets);\n      if (currentlyHighlighted) {currentlyHighlighted(); currentlyHighlighted = null;}\n    }\n    if (val) {\n      cm.state.matchBrackets = typeof val == \"object\" ? val : {};\n      cm.on(\"cursorActivity\", doMatchBrackets);\n    }\n  });\n\n  CodeMirror.defineExtension(\"matchBrackets\", function() {matchBrackets(this, true);});\n  CodeMirror.defineExtension(\"findMatchingBracket\", function(pos, strict, config){\n    return findMatchingBracket(this, pos, strict, config);\n  });\n  CodeMirror.defineExtension(\"scanForBracket\", function(pos, dir, style, config){\n    return scanForBracket(this, pos, dir, style, config);\n  });\n});\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ../~/codemirror/addon/edit/matchbrackets.js\n// module id = 593\n// module chunks = 4","// CodeMirror, copyright (c) by Marijn Haverbeke and others\n// Distributed under an MIT license: http://codemirror.net/LICENSE\n\n(function(mod) {\n  if (typeof exports == \"object\" && typeof module == \"object\") // CommonJS\n    mod(require(\"../../lib/codemirror\"));\n  else if (typeof define == \"function\" && define.amd) // AMD\n    define([\"../../lib/codemirror\"], mod);\n  else // Plain browser env\n    mod(CodeMirror);\n})(function(CodeMirror) {\n  var defaults = {\n    pairs: \"()[]{}''\\\"\\\"\",\n    triples: \"\",\n    explode: \"[]{}\"\n  };\n\n  var Pos = CodeMirror.Pos;\n\n  CodeMirror.defineOption(\"autoCloseBrackets\", false, function(cm, val, old) {\n    if (old && old != CodeMirror.Init) {\n      cm.removeKeyMap(keyMap);\n      cm.state.closeBrackets = null;\n    }\n    if (val) {\n      cm.state.closeBrackets = val;\n      cm.addKeyMap(keyMap);\n    }\n  });\n\n  function getOption(conf, name) {\n    if (name == \"pairs\" && typeof conf == \"string\") return conf;\n    if (typeof conf == \"object\" && conf[name] != null) return conf[name];\n    return defaults[name];\n  }\n\n  var bind = defaults.pairs + \"`\";\n  var keyMap = {Backspace: handleBackspace, Enter: handleEnter};\n  for (var i = 0; i < bind.length; i++)\n    keyMap[\"'\" + bind.charAt(i) + \"'\"] = handler(bind.charAt(i));\n\n  function handler(ch) {\n    return function(cm) { return handleChar(cm, ch); };\n  }\n\n  function getConfig(cm) {\n    var deflt = cm.state.closeBrackets;\n    if (!deflt || deflt.override) return deflt;\n    var mode = cm.getModeAt(cm.getCursor());\n    return mode.closeBrackets || deflt;\n  }\n\n  function handleBackspace(cm) {\n    var conf = getConfig(cm);\n    if (!conf || cm.getOption(\"disableInput\")) return CodeMirror.Pass;\n\n    var pairs = getOption(conf, \"pairs\");\n    var ranges = cm.listSelections();\n    for (var i = 0; i < ranges.length; i++) {\n      if (!ranges[i].empty()) return CodeMirror.Pass;\n      var around = charsAround(cm, ranges[i].head);\n      if (!around || pairs.indexOf(around) % 2 != 0) return CodeMirror.Pass;\n    }\n    for (var i = ranges.length - 1; i >= 0; i--) {\n      var cur = ranges[i].head;\n      cm.replaceRange(\"\", Pos(cur.line, cur.ch - 1), Pos(cur.line, cur.ch + 1), \"+delete\");\n    }\n  }\n\n  function handleEnter(cm) {\n    var conf = getConfig(cm);\n    var explode = conf && getOption(conf, \"explode\");\n    if (!explode || cm.getOption(\"disableInput\")) return CodeMirror.Pass;\n\n    var ranges = cm.listSelections();\n    for (var i = 0; i < ranges.length; i++) {\n      if (!ranges[i].empty()) return CodeMirror.Pass;\n      var around = charsAround(cm, ranges[i].head);\n      if (!around || explode.indexOf(around) % 2 != 0) return CodeMirror.Pass;\n    }\n    cm.operation(function() {\n      cm.replaceSelection(\"\\n\\n\", null);\n      cm.execCommand(\"goCharLeft\");\n      ranges = cm.listSelections();\n      for (var i = 0; i < ranges.length; i++) {\n        var line = ranges[i].head.line;\n        cm.indentLine(line, null, true);\n        cm.indentLine(line + 1, null, true);\n      }\n    });\n  }\n\n  function contractSelection(sel) {\n    var inverted = CodeMirror.cmpPos(sel.anchor, sel.head) > 0;\n    return {anchor: new Pos(sel.anchor.line, sel.anchor.ch + (inverted ? -1 : 1)),\n            head: new Pos(sel.head.line, sel.head.ch + (inverted ? 1 : -1))};\n  }\n\n  function handleChar(cm, ch) {\n    var conf = getConfig(cm);\n    if (!conf || cm.getOption(\"disableInput\")) return CodeMirror.Pass;\n\n    var pairs = getOption(conf, \"pairs\");\n    var pos = pairs.indexOf(ch);\n    if (pos == -1) return CodeMirror.Pass;\n    var triples = getOption(conf, \"triples\");\n\n    var identical = pairs.charAt(pos + 1) == ch;\n    var ranges = cm.listSelections();\n    var opening = pos % 2 == 0;\n\n    var type;\n    for (var i = 0; i < ranges.length; i++) {\n      var range = ranges[i], cur = range.head, curType;\n      var next = cm.getRange(cur, Pos(cur.line, cur.ch + 1));\n      if (opening && !range.empty()) {\n        curType = \"surround\";\n      } else if ((identical || !opening) && next == ch) {\n        if (identical && stringStartsAfter(cm, cur))\n          curType = \"both\";\n        else if (triples.indexOf(ch) >= 0 && cm.getRange(cur, Pos(cur.line, cur.ch + 3)) == ch + ch + ch)\n          curType = \"skipThree\";\n        else\n          curType = \"skip\";\n      } else if (identical && cur.ch > 1 && triples.indexOf(ch) >= 0 &&\n                 cm.getRange(Pos(cur.line, cur.ch - 2), cur) == ch + ch &&\n                 (cur.ch <= 2 || cm.getRange(Pos(cur.line, cur.ch - 3), Pos(cur.line, cur.ch - 2)) != ch)) {\n        curType = \"addFour\";\n      } else if (identical) {\n        if (!CodeMirror.isWordChar(next) && enteringString(cm, cur, ch)) curType = \"both\";\n        else return CodeMirror.Pass;\n      } else if (opening && (cm.getLine(cur.line).length == cur.ch ||\n                             isClosingBracket(next, pairs) ||\n                             /\\s/.test(next))) {\n        curType = \"both\";\n      } else {\n        return CodeMirror.Pass;\n      }\n      if (!type) type = curType;\n      else if (type != curType) return CodeMirror.Pass;\n    }\n\n    var left = pos % 2 ? pairs.charAt(pos - 1) : ch;\n    var right = pos % 2 ? ch : pairs.charAt(pos + 1);\n    cm.operation(function() {\n      if (type == \"skip\") {\n        cm.execCommand(\"goCharRight\");\n      } else if (type == \"skipThree\") {\n        for (var i = 0; i < 3; i++)\n          cm.execCommand(\"goCharRight\");\n      } else if (type == \"surround\") {\n        var sels = cm.getSelections();\n        for (var i = 0; i < sels.length; i++)\n          sels[i] = left + sels[i] + right;\n        cm.replaceSelections(sels, \"around\");\n        sels = cm.listSelections().slice();\n        for (var i = 0; i < sels.length; i++)\n          sels[i] = contractSelection(sels[i]);\n        cm.setSelections(sels);\n      } else if (type == \"both\") {\n        cm.replaceSelection(left + right, null);\n        cm.triggerElectric(left + right);\n        cm.execCommand(\"goCharLeft\");\n      } else if (type == \"addFour\") {\n        cm.replaceSelection(left + left + left + left, \"before\");\n        cm.execCommand(\"goCharRight\");\n      }\n    });\n  }\n\n  function isClosingBracket(ch, pairs) {\n    var pos = pairs.lastIndexOf(ch);\n    return pos > -1 && pos % 2 == 1;\n  }\n\n  function charsAround(cm, pos) {\n    var str = cm.getRange(Pos(pos.line, pos.ch - 1),\n                          Pos(pos.line, pos.ch + 1));\n    return str.length == 2 ? str : null;\n  }\n\n  // Project the token type that will exists after the given char is\n  // typed, and use it to determine whether it would cause the start\n  // of a string token.\n  function enteringString(cm, pos, ch) {\n    var line = cm.getLine(pos.line);\n    var token = cm.getTokenAt(pos);\n    if (/\\bstring2?\\b/.test(token.type) || stringStartsAfter(cm, pos)) return false;\n    var stream = new CodeMirror.StringStream(line.slice(0, pos.ch) + ch + line.slice(pos.ch), 4);\n    stream.pos = stream.start = token.start;\n    for (;;) {\n      var type1 = cm.getMode().token(stream, token.state);\n      if (stream.pos >= pos.ch + 1) return /\\bstring2?\\b/.test(type1);\n      stream.start = stream.pos;\n    }\n  }\n\n  function stringStartsAfter(cm, pos) {\n    var token = cm.getTokenAt(Pos(pos.line, pos.ch + 1))\n    return /\\bstring/.test(token.type) && token.start == pos.ch\n  }\n});\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ../~/codemirror/addon/edit/closebrackets.js\n// module id = 594\n// module chunks = 4","// CodeMirror, copyright (c) by Marijn Haverbeke and others\n// Distributed under an MIT license: http://codemirror.net/LICENSE\n\n(function(mod) {\n  if (typeof exports == \"object\" && typeof module == \"object\") // CommonJS\n    mod(require(\"../../lib/codemirror\"));\n  else if (typeof define == \"function\" && define.amd) // AMD\n    define([\"../../lib/codemirror\"], mod);\n  else // Plain browser env\n    mod(CodeMirror);\n})(function(CodeMirror) {\n\"use strict\";\n\nfunction expressionAllowed(stream, state, backUp) {\n  return /^(?:operator|sof|keyword c|case|new|export|default|[\\[{}\\(,;:]|=>)$/.test(state.lastType) ||\n    (state.lastType == \"quasi\" && /\\{\\s*$/.test(stream.string.slice(0, stream.pos - (backUp || 0))))\n}\n\nCodeMirror.defineMode(\"javascript\", function(config, parserConfig) {\n  var indentUnit = config.indentUnit;\n  var statementIndent = parserConfig.statementIndent;\n  var jsonldMode = parserConfig.jsonld;\n  var jsonMode = parserConfig.json || jsonldMode;\n  var isTS = parserConfig.typescript;\n  var wordRE = parserConfig.wordCharacters || /[\\w$\\xa1-\\uffff]/;\n\n  // Tokenizer\n\n  var keywords = function(){\n    function kw(type) {return {type: type, style: \"keyword\"};}\n    var A = kw(\"keyword a\"), B = kw(\"keyword b\"), C = kw(\"keyword c\");\n    var operator = kw(\"operator\"), atom = {type: \"atom\", style: \"atom\"};\n\n    var jsKeywords = {\n      \"if\": kw(\"if\"), \"while\": A, \"with\": A, \"else\": B, \"do\": B, \"try\": B, \"finally\": B,\n      \"return\": C, \"break\": C, \"continue\": C, \"new\": kw(\"new\"), \"delete\": C, \"throw\": C, \"debugger\": C,\n      \"var\": kw(\"var\"), \"const\": kw(\"var\"), \"let\": kw(\"var\"),\n      \"function\": kw(\"function\"), \"catch\": kw(\"catch\"),\n      \"for\": kw(\"for\"), \"switch\": kw(\"switch\"), \"case\": kw(\"case\"), \"default\": kw(\"default\"),\n      \"in\": operator, \"typeof\": operator, \"instanceof\": operator,\n      \"true\": atom, \"false\": atom, \"null\": atom, \"undefined\": atom, \"NaN\": atom, \"Infinity\": atom,\n      \"this\": kw(\"this\"), \"class\": kw(\"class\"), \"super\": kw(\"atom\"),\n      \"yield\": C, \"export\": kw(\"export\"), \"import\": kw(\"import\"), \"extends\": C,\n      \"await\": C, \"async\": kw(\"async\")\n    };\n\n    // Extend the 'normal' keywords with the TypeScript language extensions\n    if (isTS) {\n      var type = {type: \"variable\", style: \"variable-3\"};\n      var tsKeywords = {\n        // object-like things\n        \"interface\": kw(\"class\"),\n        \"implements\": C,\n        \"namespace\": C,\n        \"module\": kw(\"module\"),\n        \"enum\": kw(\"module\"),\n        \"type\": kw(\"type\"),\n\n        // scope modifiers\n        \"public\": kw(\"modifier\"),\n        \"private\": kw(\"modifier\"),\n        \"protected\": kw(\"modifier\"),\n        \"abstract\": kw(\"modifier\"),\n\n        // operators\n        \"as\": operator,\n\n        // types\n        \"string\": type, \"number\": type, \"boolean\": type, \"any\": type\n      };\n\n      for (var attr in tsKeywords) {\n        jsKeywords[attr] = tsKeywords[attr];\n      }\n    }\n\n    return jsKeywords;\n  }();\n\n  var isOperatorChar = /[+\\-*&%=<>!?|~^]/;\n  var isJsonldKeyword = /^@(context|id|value|language|type|container|list|set|reverse|index|base|vocab|graph)\"/;\n\n  function readRegexp(stream) {\n    var escaped = false, next, inSet = false;\n    while ((next = stream.next()) != null) {\n      if (!escaped) {\n        if (next == \"/\" && !inSet) return;\n        if (next == \"[\") inSet = true;\n        else if (inSet && next == \"]\") inSet = false;\n      }\n      escaped = !escaped && next == \"\\\\\";\n    }\n  }\n\n  // Used as scratch variables to communicate multiple values without\n  // consing up tons of objects.\n  var type, content;\n  function ret(tp, style, cont) {\n    type = tp; content = cont;\n    return style;\n  }\n  function tokenBase(stream, state) {\n    var ch = stream.next();\n    if (ch == '\"' || ch == \"'\") {\n      state.tokenize = tokenString(ch);\n      return state.tokenize(stream, state);\n    } else if (ch == \".\" && stream.match(/^\\d+(?:[eE][+\\-]?\\d+)?/)) {\n      return ret(\"number\", \"number\");\n    } else if (ch == \".\" && stream.match(\"..\")) {\n      return ret(\"spread\", \"meta\");\n    } else if (/[\\[\\]{}\\(\\),;\\:\\.]/.test(ch)) {\n      return ret(ch);\n    } else if (ch == \"=\" && stream.eat(\">\")) {\n      return ret(\"=>\", \"operator\");\n    } else if (ch == \"0\" && stream.eat(/x/i)) {\n      stream.eatWhile(/[\\da-f]/i);\n      return ret(\"number\", \"number\");\n    } else if (ch == \"0\" && stream.eat(/o/i)) {\n      stream.eatWhile(/[0-7]/i);\n      return ret(\"number\", \"number\");\n    } else if (ch == \"0\" && stream.eat(/b/i)) {\n      stream.eatWhile(/[01]/i);\n      return ret(\"number\", \"number\");\n    } else if (/\\d/.test(ch)) {\n      stream.match(/^\\d*(?:\\.\\d*)?(?:[eE][+\\-]?\\d+)?/);\n      return ret(\"number\", \"number\");\n    } else if (ch == \"/\") {\n      if (stream.eat(\"*\")) {\n        state.tokenize = tokenComment;\n        return tokenComment(stream, state);\n      } else if (stream.eat(\"/\")) {\n        stream.skipToEnd();\n        return ret(\"comment\", \"comment\");\n      } else if (expressionAllowed(stream, state, 1)) {\n        readRegexp(stream);\n        stream.match(/^\\b(([gimyu])(?![gimyu]*\\2))+\\b/);\n        return ret(\"regexp\", \"string-2\");\n      } else {\n        stream.eatWhile(isOperatorChar);\n        return ret(\"operator\", \"operator\", stream.current());\n      }\n    } else if (ch == \"`\") {\n      state.tokenize = tokenQuasi;\n      return tokenQuasi(stream, state);\n    } else if (ch == \"#\") {\n      stream.skipToEnd();\n      return ret(\"error\", \"error\");\n    } else if (isOperatorChar.test(ch)) {\n      if (ch != \">\" || !state.lexical || state.lexical.type != \">\")\n        stream.eatWhile(isOperatorChar);\n      return ret(\"operator\", \"operator\", stream.current());\n    } else if (wordRE.test(ch)) {\n      stream.eatWhile(wordRE);\n      var word = stream.current(), known = keywords.propertyIsEnumerable(word) && keywords[word];\n      return (known && state.lastType != \".\") ? ret(known.type, known.style, word) :\n                     ret(\"variable\", \"variable\", word);\n    }\n  }\n\n  function tokenString(quote) {\n    return function(stream, state) {\n      var escaped = false, next;\n      if (jsonldMode && stream.peek() == \"@\" && stream.match(isJsonldKeyword)){\n        state.tokenize = tokenBase;\n        return ret(\"jsonld-keyword\", \"meta\");\n      }\n      while ((next = stream.next()) != null) {\n        if (next == quote && !escaped) break;\n        escaped = !escaped && next == \"\\\\\";\n      }\n      if (!escaped) state.tokenize = tokenBase;\n      return ret(\"string\", \"string\");\n    };\n  }\n\n  function tokenComment(stream, state) {\n    var maybeEnd = false, ch;\n    while (ch = stream.next()) {\n      if (ch == \"/\" && maybeEnd) {\n        state.tokenize = tokenBase;\n        break;\n      }\n      maybeEnd = (ch == \"*\");\n    }\n    return ret(\"comment\", \"comment\");\n  }\n\n  function tokenQuasi(stream, state) {\n    var escaped = false, next;\n    while ((next = stream.next()) != null) {\n      if (!escaped && (next == \"`\" || next == \"$\" && stream.eat(\"{\"))) {\n        state.tokenize = tokenBase;\n        break;\n      }\n      escaped = !escaped && next == \"\\\\\";\n    }\n    return ret(\"quasi\", \"string-2\", stream.current());\n  }\n\n  var brackets = \"([{}])\";\n  // This is a crude lookahead trick to try and notice that we're\n  // parsing the argument patterns for a fat-arrow function before we\n  // actually hit the arrow token. It only works if the arrow is on\n  // the same line as the arguments and there's no strange noise\n  // (comments) in between. Fallback is to only notice when we hit the\n  // arrow, and not declare the arguments as locals for the arrow\n  // body.\n  function findFatArrow(stream, state) {\n    if (state.fatArrowAt) state.fatArrowAt = null;\n    var arrow = stream.string.indexOf(\"=>\", stream.start);\n    if (arrow < 0) return;\n\n    if (isTS) { // Try to skip TypeScript return type declarations after the arguments\n      var m = /:\\s*(?:\\w+(?:<[^>]*>|\\[\\])?|\\{[^}]*\\})\\s*$/.exec(stream.string.slice(stream.start, arrow))\n      if (m) arrow = m.index\n    }\n\n    var depth = 0, sawSomething = false;\n    for (var pos = arrow - 1; pos >= 0; --pos) {\n      var ch = stream.string.charAt(pos);\n      var bracket = brackets.indexOf(ch);\n      if (bracket >= 0 && bracket < 3) {\n        if (!depth) { ++pos; break; }\n        if (--depth == 0) { if (ch == \"(\") sawSomething = true; break; }\n      } else if (bracket >= 3 && bracket < 6) {\n        ++depth;\n      } else if (wordRE.test(ch)) {\n        sawSomething = true;\n      } else if (/[\"'\\/]/.test(ch)) {\n        return;\n      } else if (sawSomething && !depth) {\n        ++pos;\n        break;\n      }\n    }\n    if (sawSomething && !depth) state.fatArrowAt = pos;\n  }\n\n  // Parser\n\n  var atomicTypes = {\"atom\": true, \"number\": true, \"variable\": true, \"string\": true, \"regexp\": true, \"this\": true, \"jsonld-keyword\": true};\n\n  function JSLexical(indented, column, type, align, prev, info) {\n    this.indented = indented;\n    this.column = column;\n    this.type = type;\n    this.prev = prev;\n    this.info = info;\n    if (align != null) this.align = align;\n  }\n\n  function inScope(state, varname) {\n    for (var v = state.localVars; v; v = v.next)\n      if (v.name == varname) return true;\n    for (var cx = state.context; cx; cx = cx.prev) {\n      for (var v = cx.vars; v; v = v.next)\n        if (v.name == varname) return true;\n    }\n  }\n\n  function parseJS(state, style, type, content, stream) {\n    var cc = state.cc;\n    // Communicate our context to the combinators.\n    // (Less wasteful than consing up a hundred closures on every call.)\n    cx.state = state; cx.stream = stream; cx.marked = null, cx.cc = cc; cx.style = style;\n\n    if (!state.lexical.hasOwnProperty(\"align\"))\n      state.lexical.align = true;\n\n    while(true) {\n      var combinator = cc.length ? cc.pop() : jsonMode ? expression : statement;\n      if (combinator(type, content)) {\n        while(cc.length && cc[cc.length - 1].lex)\n          cc.pop()();\n        if (cx.marked) return cx.marked;\n        if (type == \"variable\" && inScope(state, content)) return \"variable-2\";\n        return style;\n      }\n    }\n  }\n\n  // Combinator utils\n\n  var cx = {state: null, column: null, marked: null, cc: null};\n  function pass() {\n    for (var i = arguments.length - 1; i >= 0; i--) cx.cc.push(arguments[i]);\n  }\n  function cont() {\n    pass.apply(null, arguments);\n    return true;\n  }\n  function register(varname) {\n    function inList(list) {\n      for (var v = list; v; v = v.next)\n        if (v.name == varname) return true;\n      return false;\n    }\n    var state = cx.state;\n    cx.marked = \"def\";\n    if (state.context) {\n      if (inList(state.localVars)) return;\n      state.localVars = {name: varname, next: state.localVars};\n    } else {\n      if (inList(state.globalVars)) return;\n      if (parserConfig.globalVars)\n        state.globalVars = {name: varname, next: state.globalVars};\n    }\n  }\n\n  // Combinators\n\n  var defaultVars = {name: \"this\", next: {name: \"arguments\"}};\n  function pushcontext() {\n    cx.state.context = {prev: cx.state.context, vars: cx.state.localVars};\n    cx.state.localVars = defaultVars;\n  }\n  function popcontext() {\n    cx.state.localVars = cx.state.context.vars;\n    cx.state.context = cx.state.context.prev;\n  }\n  function pushlex(type, info) {\n    var result = function() {\n      var state = cx.state, indent = state.indented;\n      if (state.lexical.type == \"stat\") indent = state.lexical.indented;\n      else for (var outer = state.lexical; outer && outer.type == \")\" && outer.align; outer = outer.prev)\n        indent = outer.indented;\n      state.lexical = new JSLexical(indent, cx.stream.column(), type, null, state.lexical, info);\n    };\n    result.lex = true;\n    return result;\n  }\n  function poplex() {\n    var state = cx.state;\n    if (state.lexical.prev) {\n      if (state.lexical.type == \")\")\n        state.indented = state.lexical.indented;\n      state.lexical = state.lexical.prev;\n    }\n  }\n  poplex.lex = true;\n\n  function expect(wanted) {\n    function exp(type) {\n      if (type == wanted) return cont();\n      else if (wanted == \";\") return pass();\n      else return cont(exp);\n    };\n    return exp;\n  }\n\n  function statement(type, value) {\n    if (type == \"var\") return cont(pushlex(\"vardef\", value.length), vardef, expect(\";\"), poplex);\n    if (type == \"keyword a\") return cont(pushlex(\"form\"), parenExpr, statement, poplex);\n    if (type == \"keyword b\") return cont(pushlex(\"form\"), statement, poplex);\n    if (type == \"{\") return cont(pushlex(\"}\"), block, poplex);\n    if (type == \";\") return cont();\n    if (type == \"if\") {\n      if (cx.state.lexical.info == \"else\" && cx.state.cc[cx.state.cc.length - 1] == poplex)\n        cx.state.cc.pop()();\n      return cont(pushlex(\"form\"), parenExpr, statement, poplex, maybeelse);\n    }\n    if (type == \"function\") return cont(functiondef);\n    if (type == \"for\") return cont(pushlex(\"form\"), forspec, statement, poplex);\n    if (type == \"variable\") return cont(pushlex(\"stat\"), maybelabel);\n    if (type == \"switch\") return cont(pushlex(\"form\"), parenExpr, pushlex(\"}\", \"switch\"), expect(\"{\"),\n                                      block, poplex, poplex);\n    if (type == \"case\") return cont(expression, expect(\":\"));\n    if (type == \"default\") return cont(expect(\":\"));\n    if (type == \"catch\") return cont(pushlex(\"form\"), pushcontext, expect(\"(\"), funarg, expect(\")\"),\n                                     statement, poplex, popcontext);\n    if (type == \"class\") return cont(pushlex(\"form\"), className, poplex);\n    if (type == \"export\") return cont(pushlex(\"stat\"), afterExport, poplex);\n    if (type == \"import\") return cont(pushlex(\"stat\"), afterImport, poplex);\n    if (type == \"module\") return cont(pushlex(\"form\"), pattern, pushlex(\"}\"), expect(\"{\"), block, poplex, poplex)\n    if (type == \"type\") return cont(typeexpr, expect(\"operator\"), typeexpr, expect(\";\"));\n    if (type == \"async\") return cont(statement)\n    return pass(pushlex(\"stat\"), expression, expect(\";\"), poplex);\n  }\n  function expression(type) {\n    return expressionInner(type, false);\n  }\n  function expressionNoComma(type) {\n    return expressionInner(type, true);\n  }\n  function parenExpr(type) {\n    if (type != \"(\") return pass()\n    return cont(pushlex(\")\"), expression, expect(\")\"), poplex)\n  }\n  function expressionInner(type, noComma) {\n    if (cx.state.fatArrowAt == cx.stream.start) {\n      var body = noComma ? arrowBodyNoComma : arrowBody;\n      if (type == \"(\") return cont(pushcontext, pushlex(\")\"), commasep(pattern, \")\"), poplex, expect(\"=>\"), body, popcontext);\n      else if (type == \"variable\") return pass(pushcontext, pattern, expect(\"=>\"), body, popcontext);\n    }\n\n    var maybeop = noComma ? maybeoperatorNoComma : maybeoperatorComma;\n    if (atomicTypes.hasOwnProperty(type)) return cont(maybeop);\n    if (type == \"function\") return cont(functiondef, maybeop);\n    if (type == \"class\") return cont(pushlex(\"form\"), classExpression, poplex);\n    if (type == \"keyword c\" || type == \"async\") return cont(noComma ? maybeexpressionNoComma : maybeexpression);\n    if (type == \"(\") return cont(pushlex(\")\"), maybeexpression, expect(\")\"), poplex, maybeop);\n    if (type == \"operator\" || type == \"spread\") return cont(noComma ? expressionNoComma : expression);\n    if (type == \"[\") return cont(pushlex(\"]\"), arrayLiteral, poplex, maybeop);\n    if (type == \"{\") return contCommasep(objprop, \"}\", null, maybeop);\n    if (type == \"quasi\") return pass(quasi, maybeop);\n    if (type == \"new\") return cont(maybeTarget(noComma));\n    return cont();\n  }\n  function maybeexpression(type) {\n    if (type.match(/[;\\}\\)\\],]/)) return pass();\n    return pass(expression);\n  }\n  function maybeexpressionNoComma(type) {\n    if (type.match(/[;\\}\\)\\],]/)) return pass();\n    return pass(expressionNoComma);\n  }\n\n  function maybeoperatorComma(type, value) {\n    if (type == \",\") return cont(expression);\n    return maybeoperatorNoComma(type, value, false);\n  }\n  function maybeoperatorNoComma(type, value, noComma) {\n    var me = noComma == false ? maybeoperatorComma : maybeoperatorNoComma;\n    var expr = noComma == false ? expression : expressionNoComma;\n    if (type == \"=>\") return cont(pushcontext, noComma ? arrowBodyNoComma : arrowBody, popcontext);\n    if (type == \"operator\") {\n      if (/\\+\\+|--/.test(value)) return cont(me);\n      if (value == \"?\") return cont(expression, expect(\":\"), expr);\n      return cont(expr);\n    }\n    if (type == \"quasi\") { return pass(quasi, me); }\n    if (type == \";\") return;\n    if (type == \"(\") return contCommasep(expressionNoComma, \")\", \"call\", me);\n    if (type == \".\") return cont(property, me);\n    if (type == \"[\") return cont(pushlex(\"]\"), maybeexpression, expect(\"]\"), poplex, me);\n  }\n  function quasi(type, value) {\n    if (type != \"quasi\") return pass();\n    if (value.slice(value.length - 2) != \"${\") return cont(quasi);\n    return cont(expression, continueQuasi);\n  }\n  function continueQuasi(type) {\n    if (type == \"}\") {\n      cx.marked = \"string-2\";\n      cx.state.tokenize = tokenQuasi;\n      return cont(quasi);\n    }\n  }\n  function arrowBody(type) {\n    findFatArrow(cx.stream, cx.state);\n    return pass(type == \"{\" ? statement : expression);\n  }\n  function arrowBodyNoComma(type) {\n    findFatArrow(cx.stream, cx.state);\n    return pass(type == \"{\" ? statement : expressionNoComma);\n  }\n  function maybeTarget(noComma) {\n    return function(type) {\n      if (type == \".\") return cont(noComma ? targetNoComma : target);\n      else return pass(noComma ? expressionNoComma : expression);\n    };\n  }\n  function target(_, value) {\n    if (value == \"target\") { cx.marked = \"keyword\"; return cont(maybeoperatorComma); }\n  }\n  function targetNoComma(_, value) {\n    if (value == \"target\") { cx.marked = \"keyword\"; return cont(maybeoperatorNoComma); }\n  }\n  function maybelabel(type) {\n    if (type == \":\") return cont(poplex, statement);\n    return pass(maybeoperatorComma, expect(\";\"), poplex);\n  }\n  function property(type) {\n    if (type == \"variable\") {cx.marked = \"property\"; return cont();}\n  }\n  function objprop(type, value) {\n    if (type == \"async\") {\n      cx.marked = \"property\";\n      return cont(objprop);\n    } else if (type == \"variable\" || cx.style == \"keyword\") {\n      cx.marked = \"property\";\n      if (value == \"get\" || value == \"set\") return cont(getterSetter);\n      return cont(afterprop);\n    } else if (type == \"number\" || type == \"string\") {\n      cx.marked = jsonldMode ? \"property\" : (cx.style + \" property\");\n      return cont(afterprop);\n    } else if (type == \"jsonld-keyword\") {\n      return cont(afterprop);\n    } else if (type == \"modifier\") {\n      return cont(objprop)\n    } else if (type == \"[\") {\n      return cont(expression, expect(\"]\"), afterprop);\n    } else if (type == \"spread\") {\n      return cont(expression);\n    } else if (type == \":\") {\n      return pass(afterprop)\n    }\n  }\n  function getterSetter(type) {\n    if (type != \"variable\") return pass(afterprop);\n    cx.marked = \"property\";\n    return cont(functiondef);\n  }\n  function afterprop(type) {\n    if (type == \":\") return cont(expressionNoComma);\n    if (type == \"(\") return pass(functiondef);\n  }\n  function commasep(what, end, sep) {\n    function proceed(type, value) {\n      if (sep ? sep.indexOf(type) > -1 : type == \",\") {\n        var lex = cx.state.lexical;\n        if (lex.info == \"call\") lex.pos = (lex.pos || 0) + 1;\n        return cont(function(type, value) {\n          if (type == end || value == end) return pass()\n          return pass(what)\n        }, proceed);\n      }\n      if (type == end || value == end) return cont();\n      return cont(expect(end));\n    }\n    return function(type, value) {\n      if (type == end || value == end) return cont();\n      return pass(what, proceed);\n    };\n  }\n  function contCommasep(what, end, info) {\n    for (var i = 3; i < arguments.length; i++)\n      cx.cc.push(arguments[i]);\n    return cont(pushlex(end, info), commasep(what, end), poplex);\n  }\n  function block(type) {\n    if (type == \"}\") return cont();\n    return pass(statement, block);\n  }\n  function maybetype(type, value) {\n    if (isTS) {\n      if (type == \":\") return cont(typeexpr);\n      if (value == \"?\") return cont(maybetype);\n    }\n  }\n  function typeexpr(type) {\n    if (type == \"variable\") {cx.marked = \"variable-3\"; return cont(afterType);}\n    if (type == \"string\" || type == \"number\" || type == \"atom\") return cont(afterType);\n    if (type == \"{\") return cont(pushlex(\"}\"), commasep(typeprop, \"}\", \",;\"), poplex)\n    if (type == \"(\") return cont(commasep(typearg, \")\"), maybeReturnType)\n  }\n  function maybeReturnType(type) {\n    if (type == \"=>\") return cont(typeexpr)\n  }\n  function typeprop(type, value) {\n    if (type == \"variable\" || cx.style == \"keyword\") {\n      cx.marked = \"property\"\n      return cont(typeprop)\n    } else if (value == \"?\") {\n      return cont(typeprop)\n    } else if (type == \":\") {\n      return cont(typeexpr)\n    }\n  }\n  function typearg(type) {\n    if (type == \"variable\") return cont(typearg)\n    else if (type == \":\") return cont(typeexpr)\n  }\n  function afterType(type, value) {\n    if (value == \"<\") return cont(pushlex(\">\"), commasep(typeexpr, \">\"), poplex, afterType)\n    if (value == \"|\" || type == \".\") return cont(typeexpr)\n    if (type == \"[\") return cont(expect(\"]\"), afterType)\n  }\n  function vardef() {\n    return pass(pattern, maybetype, maybeAssign, vardefCont);\n  }\n  function pattern(type, value) {\n    if (type == \"modifier\") return cont(pattern)\n    if (type == \"variable\") { register(value); return cont(); }\n    if (type == \"spread\") return cont(pattern);\n    if (type == \"[\") return contCommasep(pattern, \"]\");\n    if (type == \"{\") return contCommasep(proppattern, \"}\");\n  }\n  function proppattern(type, value) {\n    if (type == \"variable\" && !cx.stream.match(/^\\s*:/, false)) {\n      register(value);\n      return cont(maybeAssign);\n    }\n    if (type == \"variable\") cx.marked = \"property\";\n    if (type == \"spread\") return cont(pattern);\n    if (type == \"}\") return pass();\n    return cont(expect(\":\"), pattern, maybeAssign);\n  }\n  function maybeAssign(_type, value) {\n    if (value == \"=\") return cont(expressionNoComma);\n  }\n  function vardefCont(type) {\n    if (type == \",\") return cont(vardef);\n  }\n  function maybeelse(type, value) {\n    if (type == \"keyword b\" && value == \"else\") return cont(pushlex(\"form\", \"else\"), statement, poplex);\n  }\n  function forspec(type) {\n    if (type == \"(\") return cont(pushlex(\")\"), forspec1, expect(\")\"), poplex);\n  }\n  function forspec1(type) {\n    if (type == \"var\") return cont(vardef, expect(\";\"), forspec2);\n    if (type == \";\") return cont(forspec2);\n    if (type == \"variable\") return cont(formaybeinof);\n    return pass(expression, expect(\";\"), forspec2);\n  }\n  function formaybeinof(_type, value) {\n    if (value == \"in\" || value == \"of\") { cx.marked = \"keyword\"; return cont(expression); }\n    return cont(maybeoperatorComma, forspec2);\n  }\n  function forspec2(type, value) {\n    if (type == \";\") return cont(forspec3);\n    if (value == \"in\" || value == \"of\") { cx.marked = \"keyword\"; return cont(expression); }\n    return pass(expression, expect(\";\"), forspec3);\n  }\n  function forspec3(type) {\n    if (type != \")\") cont(expression);\n  }\n  function functiondef(type, value) {\n    if (value == \"*\") {cx.marked = \"keyword\"; return cont(functiondef);}\n    if (type == \"variable\") {register(value); return cont(functiondef);}\n    if (type == \"(\") return cont(pushcontext, pushlex(\")\"), commasep(funarg, \")\"), poplex, maybetype, statement, popcontext);\n  }\n  function funarg(type) {\n    if (type == \"spread\") return cont(funarg);\n    return pass(pattern, maybetype, maybeAssign);\n  }\n  function classExpression(type, value) {\n    // Class expressions may have an optional name.\n    if (type == \"variable\") return className(type, value);\n    return classNameAfter(type, value);\n  }\n  function className(type, value) {\n    if (type == \"variable\") {register(value); return cont(classNameAfter);}\n  }\n  function classNameAfter(type, value) {\n    if (value == \"extends\" || value == \"implements\" || (isTS && type == \",\"))\n      return cont(isTS ? typeexpr : expression, classNameAfter);\n    if (type == \"{\") return cont(pushlex(\"}\"), classBody, poplex);\n  }\n  function classBody(type, value) {\n    if (type == \"variable\" || cx.style == \"keyword\") {\n      if ((value == \"async\" || value == \"static\" || value == \"get\" || value == \"set\" ||\n           (isTS && (value == \"public\" || value == \"private\" || value == \"protected\" || value == \"readonly\" || value == \"abstract\"))) &&\n          cx.stream.match(/^\\s+[\\w$\\xa1-\\uffff]/, false)) {\n        cx.marked = \"keyword\";\n        return cont(classBody);\n      }\n      cx.marked = \"property\";\n      return cont(isTS ? classfield : functiondef, classBody);\n    }\n    if (type == \"[\")\n      return cont(expression, expect(\"]\"), isTS ? classfield : functiondef, classBody)\n    if (value == \"*\") {\n      cx.marked = \"keyword\";\n      return cont(classBody);\n    }\n    if (type == \";\") return cont(classBody);\n    if (type == \"}\") return cont();\n  }\n  function classfield(type, value) {\n    if (value == \"?\") return cont(classfield)\n    if (type == \":\") return cont(typeexpr, maybeAssign)\n    return pass(functiondef)\n  }\n  function afterExport(type, value) {\n    if (value == \"*\") { cx.marked = \"keyword\"; return cont(maybeFrom, expect(\";\")); }\n    if (value == \"default\") { cx.marked = \"keyword\"; return cont(expression, expect(\";\")); }\n    if (type == \"{\") return cont(commasep(exportField, \"}\"), maybeFrom, expect(\";\"));\n    return pass(statement);\n  }\n  function exportField(type, value) {\n    if (value == \"as\") { cx.marked = \"keyword\"; return cont(expect(\"variable\")); }\n    if (type == \"variable\") return pass(expressionNoComma, exportField);\n  }\n  function afterImport(type) {\n    if (type == \"string\") return cont();\n    return pass(importSpec, maybeMoreImports, maybeFrom);\n  }\n  function importSpec(type, value) {\n    if (type == \"{\") return contCommasep(importSpec, \"}\");\n    if (type == \"variable\") register(value);\n    if (value == \"*\") cx.marked = \"keyword\";\n    return cont(maybeAs);\n  }\n  function maybeMoreImports(type) {\n    if (type == \",\") return cont(importSpec, maybeMoreImports)\n  }\n  function maybeAs(_type, value) {\n    if (value == \"as\") { cx.marked = \"keyword\"; return cont(importSpec); }\n  }\n  function maybeFrom(_type, value) {\n    if (value == \"from\") { cx.marked = \"keyword\"; return cont(expression); }\n  }\n  function arrayLiteral(type) {\n    if (type == \"]\") return cont();\n    return pass(commasep(expressionNoComma, \"]\"));\n  }\n\n  function isContinuedStatement(state, textAfter) {\n    return state.lastType == \"operator\" || state.lastType == \",\" ||\n      isOperatorChar.test(textAfter.charAt(0)) ||\n      /[,.]/.test(textAfter.charAt(0));\n  }\n\n  // Interface\n\n  return {\n    startState: function(basecolumn) {\n      var state = {\n        tokenize: tokenBase,\n        lastType: \"sof\",\n        cc: [],\n        lexical: new JSLexical((basecolumn || 0) - indentUnit, 0, \"block\", false),\n        localVars: parserConfig.localVars,\n        context: parserConfig.localVars && {vars: parserConfig.localVars},\n        indented: basecolumn || 0\n      };\n      if (parserConfig.globalVars && typeof parserConfig.globalVars == \"object\")\n        state.globalVars = parserConfig.globalVars;\n      return state;\n    },\n\n    token: function(stream, state) {\n      if (stream.sol()) {\n        if (!state.lexical.hasOwnProperty(\"align\"))\n          state.lexical.align = false;\n        state.indented = stream.indentation();\n        findFatArrow(stream, state);\n      }\n      if (state.tokenize != tokenComment && stream.eatSpace()) return null;\n      var style = state.tokenize(stream, state);\n      if (type == \"comment\") return style;\n      state.lastType = type == \"operator\" && (content == \"++\" || content == \"--\") ? \"incdec\" : type;\n      return parseJS(state, style, type, content, stream);\n    },\n\n    indent: function(state, textAfter) {\n      if (state.tokenize == tokenComment) return CodeMirror.Pass;\n      if (state.tokenize != tokenBase) return 0;\n      var firstChar = textAfter && textAfter.charAt(0), lexical = state.lexical, top\n      // Kludge to prevent 'maybelse' from blocking lexical scope pops\n      if (!/^\\s*else\\b/.test(textAfter)) for (var i = state.cc.length - 1; i >= 0; --i) {\n        var c = state.cc[i];\n        if (c == poplex) lexical = lexical.prev;\n        else if (c != maybeelse) break;\n      }\n      while ((lexical.type == \"stat\" || lexical.type == \"form\") &&\n             (firstChar == \"}\" || ((top = state.cc[state.cc.length - 1]) &&\n                                   (top == maybeoperatorComma || top == maybeoperatorNoComma) &&\n                                   !/^[,\\.=+\\-*:?[\\(]/.test(textAfter))))\n        lexical = lexical.prev;\n      if (statementIndent && lexical.type == \")\" && lexical.prev.type == \"stat\")\n        lexical = lexical.prev;\n      var type = lexical.type, closing = firstChar == type;\n\n      if (type == \"vardef\") return lexical.indented + (state.lastType == \"operator\" || state.lastType == \",\" ? lexical.info + 1 : 0);\n      else if (type == \"form\" && firstChar == \"{\") return lexical.indented;\n      else if (type == \"form\") return lexical.indented + indentUnit;\n      else if (type == \"stat\")\n        return lexical.indented + (isContinuedStatement(state, textAfter) ? statementIndent || indentUnit : 0);\n      else if (lexical.info == \"switch\" && !closing && parserConfig.doubleIndentSwitch != false)\n        return lexical.indented + (/^(?:case|default)\\b/.test(textAfter) ? indentUnit : 2 * indentUnit);\n      else if (lexical.align) return lexical.column + (closing ? 0 : 1);\n      else return lexical.indented + (closing ? 0 : indentUnit);\n    },\n\n    electricInput: /^\\s*(?:case .*?:|default:|\\{|\\})$/,\n    blockCommentStart: jsonMode ? null : \"/*\",\n    blockCommentEnd: jsonMode ? null : \"*/\",\n    lineComment: jsonMode ? null : \"//\",\n    fold: \"brace\",\n    closeBrackets: \"()[]{}''\\\"\\\"``\",\n\n    helperType: jsonMode ? \"json\" : \"javascript\",\n    jsonldMode: jsonldMode,\n    jsonMode: jsonMode,\n\n    expressionAllowed: expressionAllowed,\n    skipExpression: function(state) {\n      var top = state.cc[state.cc.length - 1]\n      if (top == expression || top == expressionNoComma) state.cc.pop()\n    }\n  };\n});\n\nCodeMirror.registerHelper(\"wordChars\", \"javascript\", /[\\w$]/);\n\nCodeMirror.defineMIME(\"text/javascript\", \"javascript\");\nCodeMirror.defineMIME(\"text/ecmascript\", \"javascript\");\nCodeMirror.defineMIME(\"application/javascript\", \"javascript\");\nCodeMirror.defineMIME(\"application/x-javascript\", \"javascript\");\nCodeMirror.defineMIME(\"application/ecmascript\", \"javascript\");\nCodeMirror.defineMIME(\"application/json\", {name: \"javascript\", json: true});\nCodeMirror.defineMIME(\"application/x-json\", {name: \"javascript\", json: true});\nCodeMirror.defineMIME(\"application/ld+json\", {name: \"javascript\", jsonld: true});\nCodeMirror.defineMIME(\"text/typescript\", { name: \"javascript\", typescript: true });\nCodeMirror.defineMIME(\"application/typescript\", { name: \"javascript\", typescript: true });\n\n});\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ../~/codemirror/mode/javascript/javascript.js\n// module id = 595\n// module chunks = 4","export default {\n    SET_VALUE_EVENT: 'setValue'\n};\n\n\n\n// WEBPACK FOOTER //\n// ../~/angular2-template-loader!./app/scenarios/scenario-details/editor/scenario-editor/code-mirror-events.const.ts","import { EventEmitter } from '@angular/core';\nimport { Component, Output, Input } from '@angular/core';\n\nimport { Scenario } from '../scenario-entities/scenario';\nimport LOGICAL_OPERATORS from '../scenario-entities/logical-operators.const';\n\n@Component({\n    selector: 'sh-scenario-wizard',\n    template: require('./scenario-wizard.template.html'),\n    styles: [require('./scenario-wizard.style.scss')]\n})\nexport class ScenarioWizardComponent {\n\n    @Input() scenario: Scenario;\n\n    @Output() onAddCriteria: EventEmitter<any>;\n    @Output() onRemoveCriteria: EventEmitter<any>;\n    @Output() onAddAction: EventEmitter<any>;\n    @Output() onRemoveAction: EventEmitter<any>;\n\n    private LOGICAL_OPERATORS;\n\n    constructor() {\n        this.onAddCriteria = new EventEmitter();\n        this.onRemoveCriteria = new EventEmitter();\n        this.onAddAction = new EventEmitter();\n        this.onRemoveAction = new EventEmitter();\n\n        this.LOGICAL_OPERATORS = LOGICAL_OPERATORS;\n    }\n\n    addCriteria() {\n        this.onAddCriteria.next();\n    }\n\n    removeCriteria(index) {\n        this.onRemoveCriteria.emit(index);\n    }\n\n    addAction() {\n        this.onAddAction.next();\n    }\n\n    removeAction(index) {\n        this.onRemoveAction.emit(index);\n    }\n\n    removeActionBtnVisible() {\n        return this.scenario['wizard']['actions'].length > 1;\n    }\n}\n\n\n\n// WEBPACK FOOTER //\n// ../~/angular2-template-loader!./app/scenarios/scenario-details/wizard/scenario-wizard/scenario-wizard.component.ts","const operators = [\n    {id: 'AND', name: 'ALL'},\n    {id: 'OR', name: 'ANY'}\n];\nexport default operators;\n\n\n\n// WEBPACK FOOTER //\n// ../~/angular2-template-loader!./app/scenarios/scenario-details/wizard/scenario-entities/logical-operators.const.ts","module.exports = \"<div class=\\\"row\\\">\\n    <div class=\\\"input-field col s6\\\">\\n        <label for=\\\"scenario-wizard__name\\\">Scenario Name <b class=\\\"red-text\\\">*</b></label>\\n        <input id=\\\"scenario-wizard__name\\\" type=\\\"text\\\" required\\n               class=\\\"scenario-name\\\"\\n               placeholder=\\\"Enter descriptive scenario name\\\"\\n               [(ngModel)]=\\\"scenario.name\\\"\\n               #scenarioName=\\\"ngModel\\\"/>\\n        <div [hidden]=\\\"!scenarioName.touched || scenarioName.valid\\\" class=\\\"validation-alert\\\">\\n            Scenario name should be filled\\n        </div>\\n    </div>\\n</div>\\n\\n<div class=\\\"row\\\">\\n    <div class=\\\"col\\\">\\n        <h5>\\n            If\\n            <select name=\\\"logicalOperator\\\"\\n                    class=\\\"operators-select\\\"\\n                    [(ngModel)]=\\\"scenario.wizard.logicalOperator\\\">\\n                <option *ngFor=\\\"let operator of LOGICAL_OPERATORS\\\"\\n                        [value]=\\\"operator.id\\\">{{operator.name}}\\n                </option>\\n            </select>\\n            of the conditions are true\\n        </h5>\\n\\n    </div>\\n</div>\\n<div class=\\\"row gray-bg\\\" *ngFor=\\\"let condition of scenario.wizard.conditions; let i=index\\\">\\n    <div class=\\\"col s3\\\">\\n        <label [attr.for]=\\\"'scenario-wizard__device'+i\\\">Device <b class=\\\"red-text\\\">*</b></label>\\n        <select id=\\\"scenario-wizard__device{{i}}\\\" required name=\\\"deviceSelect\\\"\\n                [(ngModel)]=\\\"condition.selectedDevice\\\">\\n            <option [value]=\\\"undefined\\\" disabled>Choose trigger</option>\\n            <option *ngFor=\\\"let device of condition.devices\\\"\\n                    [value]=\\\"device.mqttId\\\">{{device.description}}\\n            </option>\\n        </select>\\n    </div>\\n    <div class=\\\"col s4\\\">\\n        <label [attr.for]=\\\"'scenario-wizard__condition'+i\\\">Condition <b class=\\\"red-text\\\">*</b></label>\\n        <select id=\\\"scenario-wizard__condition{{i}}\\\" required name=\\\"conditionSelect\\\"\\n                [(ngModel)]=\\\"condition.selectedCondition\\\">\\n            <option [value]=\\\"undefined\\\" disabled>Choose condition</option>\\n            <option *ngFor=\\\"let condition of condition.conditions\\\" [value]=\\\"condition.id\\\">{{condition.name}}</option>\\n        </select>\\n    </div>\\n    <div class=\\\"col s3\\\">\\n        <label [attr.for]=\\\"'scenario-wizard__value'+i\\\">Value <b class=\\\"red-text\\\">*</b></label>\\n        <input id=\\\"scenario-wizard__value{{i}}\\\"\\n               type=\\\"number\\\"\\n               required\\n               #conditionValue=\\\"ngModel\\\"\\n               [(ngModel)]=\\\"condition.value\\\"\\n               placeholder=\\\"Enter value\\\"/>\\n        <div class=\\\"validation-alert\\\" [hidden]=\\\"!conditionValue.touched || conditionValue.valid\\\">\\n            Field format is incorrect\\n        </div>\\n    </div>\\n    <div class=\\\"col s1 remove-wrapper\\\"\\n         *ngIf=\\\"scenario.wizard.conditions.length>1\\\">\\n        <div class=\\\"icon-wrapper\\\">\\n            <i class=\\\"material-icons center\\\"\\n               (click)=\\\"removeCriteria(i)\\\"\\n            >delete</i>\\n        </div>\\n    </div>\\n</div>\\n<div class=\\\"row\\\">\\n    <div class=\\\"col\\\">\\n        <a (click)=\\\"addCriteria()\\\">+ ADD CRITERIA</a>\\n    </div>\\n</div>\\n<div class=\\\"row\\\">\\n    <div class=\\\"col\\\">\\n        <h5>Then do the following</h5>\\n    </div>\\n</div>\\n<div class=\\\"row gray-bg\\\" *ngFor=\\\"let action of scenario.wizard.actions; let i=index;\\\">\\n    <div class=\\\"col s3\\\">\\n        <label [attr.for]=\\\"'scenario-wizard__device'+i\\\">Device</label>\\n        <select id=\\\"scenario-wizard__device{{i}}\\\" [(ngModel)]=\\\"action.selectedDevice\\\">\\n            <option [value]=\\\"undefined\\\">Choose device</option>\\n            <option *ngFor=\\\"let device of action.devices\\\"\\n                    [value]=\\\"device.mqttId\\\">{{device.description}}\\n            </option>\\n        </select>\\n    </div>\\n    <div class=\\\"col s3\\\">\\n        <label [attr.for]=\\\"'scenario-wizard__value'+i\\\">Value</label>\\n        <select id=\\\"scenario-wizard__value{{i}}\\\" name=\\\"actionValue\\\"\\n                [(ngModel)]=\\\"action.value\\\">\\n            <option *ngFor=\\\"let value of action.values\\\"\\n                    [value]=\\\"value.id\\\">{{value.name}}\\n            </option>\\n        </select>\\n    </div>\\n    <div class=\\\"col s1 remove-wrapper\\\"\\n         *ngIf=\\\"removeActionBtnVisible()\\\">\\n        <div class=\\\"icon-wrapper\\\">\\n            <i (click)=\\\"removeAction(i)\\\" class=\\\"material-icons center\\\">delete</i>\\n        </div>\\n    </div>\\n</div>\\n\\n<div class=\\\"row\\\">\\n    <div class=\\\"col\\\">\\n        <a (click)=\\\"addAction()\\\">+ ADD ACTION</a>\\n    </div>\\n</div>\\n\"\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./app/scenarios/scenario-details/wizard/scenario-wizard/scenario-wizard.template.html\n// module id = 599\n// module chunks = 4","module.exports = \"select{display:block;border:0px solid white;padding:0px;width:auto;background-color:whitesmoke}select.condition-select{display:inline}.operators-select{display:inline;background-color:white}.gray-bg{background-color:whitesmoke}a{cursor:pointer;font-size:15px;color:#01579b}input[type=\\\"number\\\"]::-webkit-outer-spin-button,input[type=\\\"number\\\"]::-webkit-inner-spin-button{-webkit-appearance:none;margin:0}.material-icons{cursor:pointer}.icon-wrapper{position:absolute;top:50%;left:50%;transform:translate(-50%, -50%)}.remove-wrapper{height:80px;position:relative}.input-field label{position:relative;left:0;font-family:Roboto-Regular;font-size:13px}.scenario-name{margin-top:11px}\\n\"\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./app/scenarios/scenario-details/wizard/scenario-wizard/scenario-wizard.style.scss\n// module id = 600\n// module chunks = 4","\n/**\n * This is the web browser implementation of `debug()`.\n *\n * Expose `debug()` as the module.\n */\n\nexports = module.exports = require('./debug');\nexports.log = log;\nexports.formatArgs = formatArgs;\nexports.save = save;\nexports.load = load;\nexports.useColors = useColors;\nexports.storage = 'undefined' != typeof chrome\n               && 'undefined' != typeof chrome.storage\n                  ? chrome.storage.local\n                  : localstorage();\n\n/**\n * Colors.\n */\n\nexports.colors = [\n  'lightseagreen',\n  'forestgreen',\n  'goldenrod',\n  'dodgerblue',\n  'darkorchid',\n  'crimson'\n];\n\n/**\n * Currently only WebKit-based Web Inspectors, Firefox >= v31,\n * and the Firebug extension (any Firefox version) are known\n * to support \"%c\" CSS customizations.\n *\n * TODO: add a `localStorage` variable to explicitly enable/disable colors\n */\n\nfunction useColors() {\n  // is webkit? http://stackoverflow.com/a/16459606/376773\n  // document is undefined in react-native: https://github.com/facebook/react-native/pull/1632\n  return (typeof document !== 'undefined' && 'WebkitAppearance' in document.documentElement.style) ||\n    // is firebug? http://stackoverflow.com/a/398120/376773\n    (window.console && (console.firebug || (console.exception && console.table))) ||\n    // is firefox >= v31?\n    // https://developer.mozilla.org/en-US/docs/Tools/Web_Console#Styling_messages\n    (navigator.userAgent.toLowerCase().match(/firefox\\/(\\d+)/) && parseInt(RegExp.$1, 10) >= 31);\n}\n\n/**\n * Map %j to `JSON.stringify()`, since no Web Inspectors do that by default.\n */\n\nexports.formatters.j = function(v) {\n  try {\n    return JSON.stringify(v);\n  } catch (err) {\n    return '[UnexpectedJSONParseError]: ' + err.message;\n  }\n};\n\n\n/**\n * Colorize log arguments if enabled.\n *\n * @api public\n */\n\nfunction formatArgs() {\n  var args = arguments;\n  var useColors = this.useColors;\n\n  args[0] = (useColors ? '%c' : '')\n    + this.namespace\n    + (useColors ? ' %c' : ' ')\n    + args[0]\n    + (useColors ? '%c ' : ' ')\n    + '+' + exports.humanize(this.diff);\n\n  if (!useColors) return args;\n\n  var c = 'color: ' + this.color;\n  args = [args[0], c, 'color: inherit'].concat(Array.prototype.slice.call(args, 1));\n\n  // the final \"%c\" is somewhat tricky, because there could be other\n  // arguments passed either before or after the %c, so we need to\n  // figure out the correct index to insert the CSS into\n  var index = 0;\n  var lastC = 0;\n  args[0].replace(/%[a-z%]/g, function(match) {\n    if ('%%' === match) return;\n    index++;\n    if ('%c' === match) {\n      // we only are interested in the *last* %c\n      // (the user may have provided their own)\n      lastC = index;\n    }\n  });\n\n  args.splice(lastC, 0, c);\n  return args;\n}\n\n/**\n * Invokes `console.log()` when available.\n * No-op when `console.log` is not a \"function\".\n *\n * @api public\n */\n\nfunction log() {\n  // this hackery is required for IE8/9, where\n  // the `console.log` function doesn't have 'apply'\n  return 'object' === typeof console\n    && console.log\n    && Function.prototype.apply.call(console.log, console, arguments);\n}\n\n/**\n * Save `namespaces`.\n *\n * @param {String} namespaces\n * @api private\n */\n\nfunction save(namespaces) {\n  try {\n    if (null == namespaces) {\n      exports.storage.removeItem('debug');\n    } else {\n      exports.storage.debug = namespaces;\n    }\n  } catch(e) {}\n}\n\n/**\n * Load `namespaces`.\n *\n * @return {String} returns the previously persisted debug modes\n * @api private\n */\n\nfunction load() {\n  var r;\n  try {\n    return exports.storage.debug;\n  } catch(e) {}\n\n  // If debug isn't set in LS, and we're in Electron, try to load $DEBUG\n  if (typeof process !== 'undefined' && 'env' in process) {\n    return process.env.DEBUG;\n  }\n}\n\n/**\n * Enable namespaces listed in `localStorage.debug` initially.\n */\n\nexports.enable(load());\n\n/**\n * Localstorage attempts to return the localstorage.\n *\n * This is necessary because safari throws\n * when a user disables cookies/localstorage\n * and you attempt to access it.\n *\n * @return {LocalStorage}\n * @api private\n */\n\nfunction localstorage(){\n  try {\n    return window.localStorage;\n  } catch (e) {}\n}\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ../~/socket.io-client/~/debug/browser.js\n// module id = 449\n// module chunks = 1 4 8 9 11"],"sourceRoot":""}