{"version":3,"file":"common.d7cefb9686239ebb.js","mappings":"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","sources":["./src/stimulus/controllers/dynamic/filter/filter-list.controller.ts","./src/stimulus/controllers/dynamic/project-storage-form.controller.ts","./node_modules/codemirror/addon/mode/multiplex.js","./node_modules/codemirror/addon/mode/overlay.js","./node_modules/codemirror/addon/mode/simple.js","./node_modules/codemirror/mode/coffeescript/coffeescript.js","./node_modules/codemirror/mode/handlebars/handlebars.js","./node_modules/codemirror/mode/haskell/haskell.js","./node_modules/codemirror/mode/pug/pug.js","./node_modules/codemirror/mode/python/python.js","./node_modules/codemirror/mode/ruby/ruby.js","./node_modules/codemirror/mode/sass/sass.js","./node_modules/codemirror/mode/stex/stex.js","./node_modules/codemirror/mode/yaml/yaml.js"],"sourcesContent":["/*\n * -- copyright\n * OpenProject is an open source project management software.\n * Copyright (C) the OpenProject GmbH\n *\n * This program is free software; you can redistribute it and/or\n * modify it under the terms of the GNU General Public License version 3.\n *\n * OpenProject is a fork of ChiliProject, which is a fork of Redmine. The copyright follows:\n * Copyright (C) 2006-2013 Jean-Philippe Lang\n * Copyright (C) 2010-2013 the ChiliProject Team\n *\n * This program is free software; you can redistribute it and/or\n * modify it under the terms of the GNU General Public License\n * as published by the Free Software Foundation; either version 2\n * of the License, or (at your option) any later version.\n *\n * This program is distributed in the hope that it will be useful,\n * but WITHOUT ANY WARRANTY; without even the implied warranty of\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\n * GNU General Public License for more details.\n *\n * You should have received a copy of the GNU General Public License\n * along with this program; if not, write to the Free Software\n * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.\n *\n * See COPYRIGHT and LICENSE files for more details.\n * ++\n */\n\nimport { Controller } from '@hotwired/stimulus';\n\nexport default class FilterListController extends Controller {\n  static targets = [\n    'filter',\n    'searchItem',\n    'noResultsText',\n  ];\n\n  static values = {\n    clearButtonId: String,\n  };\n\n  declare readonly filterTarget:HTMLInputElement;\n  declare readonly noResultsTextTarget:HTMLInputElement;\n  declare readonly hasNoResultsTextTarget:boolean;\n  declare readonly searchItemTargets:HTMLInputElement[];\n  declare readonly clearButtonIdValue:string;\n\n  connect():void {\n    document.getElementById(this.clearButtonIdValue)?.addEventListener('click', () => {\n      this.resetFilterViaClearButton();\n    });\n  }\n\n  disconnect():void {\n    document.getElementById(this.clearButtonIdValue)?.removeEventListener('click', () => {\n      this.resetFilterViaClearButton();\n    });\n  }\n\n  /**\n   * Filters the list of items based on the input value in the filter target.\n   *\n   * This method converts the input value to lowercase and compares it with the text content\n   * of each search item. To avoid unwanted text from being part of the search string. E.g. the\n   * labels of buttons, the method first tries to find an element with the class `filter-target-visible-text`.\n   * If such an element exists, only the content of that element is used for the search.\n   * If the text content includes the input value, the item is shown;\n   * otherwise, it is hidden. Additionally, it controls the visibility of the no results text\n   * based on whether any items match the input value.\n   */\n  filterLists() {\n    const query = this.filterTarget.value.toLowerCase();\n    let showNoResultsText = true;\n\n    this.searchItemTargets.forEach((item) => {\n      const text = item.querySelector('.filter-target-visible-text')?.textContent?.toLowerCase() || item.textContent?.toLowerCase();\n\n      if (text?.includes(query)) {\n        this.setVisibility(item, true);\n        showNoResultsText = false;\n      } else {\n        this.setVisibility(item, false);\n      }\n    });\n\n    if (this.hasNoResultsTextTarget) {\n      this.setVisibility(this.noResultsTextTarget, showNoResultsText);\n    }\n  }\n\n  resetFilterViaClearButton() {\n    this.searchItemTargets.forEach((item) => {\n      this.setVisibility(item, true);\n    });\n  }\n\n  setVisibility(element:HTMLElement, visible:boolean) {\n    element.classList.toggle('d-none', !visible);\n  }\n}\n","/*\n * -- copyright\n * OpenProject is an open source project management software.\n * Copyright (C) the OpenProject GmbH\n *\n * This program is free software; you can redistribute it and/or\n * modify it under the terms of the GNU General Public License version 3.\n *\n * OpenProject is a fork of ChiliProject, which is a fork of Redmine. The copyright follows:\n * Copyright (C) 2006-2013 Jean-Philippe Lang\n * Copyright (C) 2010-2013 the ChiliProject Team\n *\n * This program is free software; you can redistribute it and/or\n * modify it under the terms of the GNU General Public License\n * as published by the Free Software Foundation; either version 2\n * of the License, or (at your option) any later version.\n *\n * This program is distributed in the hope that it will be useful,\n * but WITHOUT ANY WARRANTY; without even the implied warranty of\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\n * GNU General Public License for more details.\n *\n * You should have received a copy of the GNU General Public License\n * along with this program; if not, write to the Free Software\n * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.\n *\n * See COPYRIGHT and LICENSE files for more details.\n * ++\n */\n\nimport { Controller } from '@hotwired/stimulus';\nimport {\n  combineLatest,\n  from,\n  Observable,\n  of,\n} from 'rxjs';\nimport {\n  filter,\n  map,\n  switchMap,\n} from 'rxjs/operators';\n\nimport { IStorage } from 'core-app/core/state/storages/storage.model';\nimport { IStorageFile } from 'core-app/core/state/storage-files/storage-file.model';\nimport { OpenProjectPluginContext } from 'core-app/features/plugins/plugin-context';\nimport {\n  LocationPickerModalComponent,\n} from 'core-app/shared/components/storages/location-picker-modal/location-picker-modal.component';\nimport { PortalOutletTarget } from 'core-app/shared/components/modal/portal-outlet-target.enum';\nimport { storageConnected } from 'core-app/shared/components/storages/storages-constants.const';\n\nexport default class ProjectStorageFormController extends Controller {\n  static targets = [\n    'projectFolderSection',\n    'projectFolderIdInput',\n    'projectFolderIdValidation',\n    'selectedFolderText',\n    'selectProjectFolderButton',\n    'loginButton',\n    'storage',\n  ];\n\n  static values = {\n    folderMode: String,\n    placeholderFolderName: String,\n    notLoggedInValidation: String,\n    lastProjectFolders: Object,\n  };\n\n  declare folderModeValue:string;\n  declare placeholderFolderNameValue:string;\n  declare notLoggedInValidationValue:string;\n  declare lastProjectFoldersValue:{ manual:string; automatic:string };\n\n  declare readonly storageTarget:HTMLElement;\n  declare readonly selectProjectFolderButtonTarget:HTMLButtonElement;\n  declare readonly loginButtonTarget:HTMLButtonElement;\n  declare readonly projectFolderSectionTarget:HTMLElement;\n  declare readonly projectFolderIdInputTarget:HTMLInputElement;\n  declare readonly projectFolderIdValidationTarget:HTMLSpanElement;\n  declare readonly selectedFolderTextTarget:HTMLSpanElement;\n\n  declare readonly hasProjectFolderIdValidationTarget:boolean;\n  declare readonly hasProjectFolderSectionTarget:boolean;\n\n  connect():void {\n    combineLatest([\n      this.fetchStorageAuthorizationState(),\n      this.fetchProjectFolder(),\n    ]).subscribe(([isConnected, projectFolder]) => {\n      this.displayFolderSelectionOrLoginButton(isConnected, projectFolder);\n      this.toggleFolderDisplay(this.folderModeValue);\n      this.setProjectFolderModeQueryParam(this.folderModeValue);\n    });\n  }\n\n  selectProjectFolder(_evt:Event):void {\n    const locals = {\n      projectFolderHref: this.projectFolderHref,\n      createFolderHref: `${this.storage._links.self.href}/folders`,\n      storage: this.storage,\n    };\n\n    this.pluginContext.subscribe((context) => {\n      context.runInZone(() => {\n        context.services.opModalService\n          .show(LocationPickerModalComponent, 'global', locals, false, false, this.OutletTarget)\n          .pipe(\n            switchMap((modal) => modal.closingEvent),\n            filter((modal) => modal.submitted),\n          )\n          .subscribe((modal) => {\n            if (this.hasProjectFolderIdValidationTarget) {\n              this.projectFolderIdValidationTarget.style.display = 'none';\n            }\n            this.selectedFolderTextTarget.innerText = modal.location.name;\n            this.projectFolderIdInputTarget.value = modal.location.id as string;\n          });\n      });\n    });\n  }\n\n  updateForm(evt:InputEvent):void {\n    const mode = (evt.target as HTMLInputElement).value;\n    const { manual, automatic } = this.lastProjectFoldersValue;\n\n    switch (mode) {\n      case 'manual':\n        this.projectFolderIdInputTarget.value = manual ?? '';\n\n        this.fetchProjectFolder().subscribe((projectFolder) => {\n          this.selectedFolderTextTarget.innerText = projectFolder === null\n            ? this.placeholderFolderNameValue\n            : projectFolder.name;\n        });\n\n        break;\n      case 'automatic':\n        this.projectFolderIdInputTarget.value = automatic ?? '';\n        break;\n      default:\n        this.projectFolderIdInputTarget.value = '';\n    }\n\n    this.folderModeValue = mode;\n    this.toggleFolderDisplay(mode);\n    this.setProjectFolderModeQueryParam(mode);\n  }\n\n  protected get pluginContext():Observable<OpenProjectPluginContext> {\n    return from(window.OpenProject.getPluginContext());\n  }\n\n  protected get OutletTarget():PortalOutletTarget {\n    return PortalOutletTarget.Default;\n  }\n\n  protected get storage():IStorage {\n    return JSON.parse(this.storageTarget.dataset.storage as string) as IStorage;\n  }\n\n  protected get projectFolderHref():string|null {\n    const projectFolderId = this.projectFolderIdInputTarget.value;\n\n    if (projectFolderId.length === 0) {\n      return null;\n    }\n\n    return `${this.storage._links.self.href}/files/${projectFolderId}`;\n  }\n\n  protected fetchStorageAuthorizationState():Observable<boolean> {\n    return from(fetch(this.storage._links.self.href)\n      .then((data) => data.json()))\n      .pipe(\n        map((storage:IStorage) => storage._links.authorizationState.href === storageConnected),\n      );\n  }\n\n  protected fetchProjectFolder():Observable<IStorageFile|null> {\n    const href = this.projectFolderHref;\n    if (href === null) {\n      return of(null);\n    }\n\n    return from(fetch(href).then((data) => data.json()))\n      .pipe(\n        map((file) => {\n          // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access\n          if (file._type === 'StorageFile') {\n            return file as IStorageFile;\n          }\n\n          return null;\n        }),\n      );\n  }\n\n  protected displayFolderSelectionOrLoginButton(isConnected:boolean, projectFolder:IStorageFile|null):void {\n    if (isConnected) {\n      this.selectProjectFolderButtonTarget.classList.remove('d-none');\n      this.loginButtonTarget.classList.add('d-none');\n      this.selectedFolderTextTarget.innerText = projectFolder === null\n        ? this.placeholderFolderNameValue\n        : projectFolder.name;\n    } else {\n      this.selectProjectFolderButtonTarget.classList.add('d-none');\n      this.loginButtonTarget.classList.remove('d-none');\n      this.selectedFolderTextTarget.innerText = this.notLoggedInValidationValue;\n    }\n  }\n\n  protected setProjectFolderModeQueryParam(mode:string) {\n    const url = new URL(window.location.href);\n    url.searchParams.set('storages_project_storage[project_folder_mode]', mode);\n    window.history.replaceState(window.history.state, '', url);\n  }\n\n  protected toggleFolderDisplay(value:string):void {\n    // If the manual radio button is selected, show the manual folder selection section\n    if (this.hasProjectFolderSectionTarget && value === 'manual') {\n      this.projectFolderSectionTarget.classList.remove('d-none');\n    } else {\n      this.projectFolderSectionTarget.classList.add('d-none');\n    }\n  }\n}\n","// CodeMirror, copyright (c) by Marijn Haverbeke and others\n// Distributed under an MIT license: https://codemirror.net/5/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\nCodeMirror.multiplexingMode = function(outer /*, others */) {\n  // Others should be {open, close, mode [, delimStyle] [, innerStyle] [, parseDelimiters]} objects\n  var others = Array.prototype.slice.call(arguments, 1);\n\n  function indexOf(string, pattern, from, returnEnd) {\n    if (typeof pattern == \"string\") {\n      var found = string.indexOf(pattern, from);\n      return returnEnd && found > -1 ? found + pattern.length : found;\n    }\n    var m = pattern.exec(from ? string.slice(from) : string);\n    return m ? m.index + from + (returnEnd ? m[0].length : 0) : -1;\n  }\n\n  return {\n    startState: function() {\n      return {\n        outer: CodeMirror.startState(outer),\n        innerActive: null,\n        inner: null,\n        startingInner: false\n      };\n    },\n\n    copyState: function(state) {\n      return {\n        outer: CodeMirror.copyState(outer, state.outer),\n        innerActive: state.innerActive,\n        inner: state.innerActive && CodeMirror.copyState(state.innerActive.mode, state.inner),\n        startingInner: state.startingInner\n      };\n    },\n\n    token: function(stream, state) {\n      if (!state.innerActive) {\n        var cutOff = Infinity, oldContent = stream.string;\n        for (var i = 0; i < others.length; ++i) {\n          var other = others[i];\n          var found = indexOf(oldContent, other.open, stream.pos);\n          if (found == stream.pos) {\n            if (!other.parseDelimiters) stream.match(other.open);\n            state.startingInner = !!other.parseDelimiters\n            state.innerActive = other;\n\n            // Get the outer indent, making sure to handle CodeMirror.Pass\n            var outerIndent = 0;\n            if (outer.indent) {\n              var possibleOuterIndent = outer.indent(state.outer, \"\", \"\");\n              if (possibleOuterIndent !== CodeMirror.Pass) outerIndent = possibleOuterIndent;\n            }\n\n            state.inner = CodeMirror.startState(other.mode, outerIndent);\n            return other.delimStyle && (other.delimStyle + \" \" + other.delimStyle + \"-open\");\n          } else if (found != -1 && found < cutOff) {\n            cutOff = found;\n          }\n        }\n        if (cutOff != Infinity) stream.string = oldContent.slice(0, cutOff);\n        var outerToken = outer.token(stream, state.outer);\n        if (cutOff != Infinity) stream.string = oldContent;\n        return outerToken;\n      } else {\n        var curInner = state.innerActive, oldContent = stream.string;\n        if (!curInner.close && stream.sol()) {\n          state.innerActive = state.inner = null;\n          return this.token(stream, state);\n        }\n        var found = curInner.close && !state.startingInner ?\n            indexOf(oldContent, curInner.close, stream.pos, curInner.parseDelimiters) : -1;\n        if (found == stream.pos && !curInner.parseDelimiters) {\n          stream.match(curInner.close);\n          state.innerActive = state.inner = null;\n          return curInner.delimStyle && (curInner.delimStyle + \" \" + curInner.delimStyle + \"-close\");\n        }\n        if (found > -1) stream.string = oldContent.slice(0, found);\n        var innerToken = curInner.mode.token(stream, state.inner);\n        if (found > -1) stream.string = oldContent;\n        else if (stream.pos > stream.start) state.startingInner = false\n\n        if (found == stream.pos && curInner.parseDelimiters)\n          state.innerActive = state.inner = null;\n\n        if (curInner.innerStyle) {\n          if (innerToken) innerToken = innerToken + \" \" + curInner.innerStyle;\n          else innerToken = curInner.innerStyle;\n        }\n\n        return innerToken;\n      }\n    },\n\n    indent: function(state, textAfter, line) {\n      var mode = state.innerActive ? state.innerActive.mode : outer;\n      if (!mode.indent) return CodeMirror.Pass;\n      return mode.indent(state.innerActive ? state.inner : state.outer, textAfter, line);\n    },\n\n    blankLine: function(state) {\n      var mode = state.innerActive ? state.innerActive.mode : outer;\n      if (mode.blankLine) {\n        mode.blankLine(state.innerActive ? state.inner : state.outer);\n      }\n      if (!state.innerActive) {\n        for (var i = 0; i < others.length; ++i) {\n          var other = others[i];\n          if (other.open === \"\\n\") {\n            state.innerActive = other;\n            state.inner = CodeMirror.startState(other.mode, mode.indent ? mode.indent(state.outer, \"\", \"\") : 0);\n          }\n        }\n      } else if (state.innerActive.close === \"\\n\") {\n        state.innerActive = state.inner = null;\n      }\n    },\n\n    electricChars: outer.electricChars,\n\n    innerMode: function(state) {\n      return state.inner ? {state: state.inner, mode: state.innerActive.mode} : {state: state.outer, mode: outer};\n    }\n  };\n};\n\n});\n","// CodeMirror, copyright (c) by Marijn Haverbeke and others\n// Distributed under an MIT license: https://codemirror.net/5/LICENSE\n\n// Utility function that allows modes to be combined. The mode given\n// as the base argument takes care of most of the normal mode\n// functionality, but a second (typically simple) mode is used, which\n// can override the style of text. Both modes get to parse all of the\n// text, but when both assign a non-null style to a piece of code, the\n// overlay wins, unless the combine argument was true and not overridden,\n// or state.overlay.combineTokens was true, in which case the styles are\n// combined.\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\nCodeMirror.overlayMode = function(base, overlay, combine) {\n  return {\n    startState: function() {\n      return {\n        base: CodeMirror.startState(base),\n        overlay: CodeMirror.startState(overlay),\n        basePos: 0, baseCur: null,\n        overlayPos: 0, overlayCur: null,\n        streamSeen: null\n      };\n    },\n    copyState: function(state) {\n      return {\n        base: CodeMirror.copyState(base, state.base),\n        overlay: CodeMirror.copyState(overlay, state.overlay),\n        basePos: state.basePos, baseCur: null,\n        overlayPos: state.overlayPos, overlayCur: null\n      };\n    },\n\n    token: function(stream, state) {\n      if (stream != state.streamSeen ||\n          Math.min(state.basePos, state.overlayPos) < stream.start) {\n        state.streamSeen = stream;\n        state.basePos = state.overlayPos = stream.start;\n      }\n\n      if (stream.start == state.basePos) {\n        state.baseCur = base.token(stream, state.base);\n        state.basePos = stream.pos;\n      }\n      if (stream.start == state.overlayPos) {\n        stream.pos = stream.start;\n        state.overlayCur = overlay.token(stream, state.overlay);\n        state.overlayPos = stream.pos;\n      }\n      stream.pos = Math.min(state.basePos, state.overlayPos);\n\n      // state.overlay.combineTokens always takes precedence over combine,\n      // unless set to null\n      if (state.overlayCur == null) return state.baseCur;\n      else if (state.baseCur != null &&\n               state.overlay.combineTokens ||\n               combine && state.overlay.combineTokens == null)\n        return state.baseCur + \" \" + state.overlayCur;\n      else return state.overlayCur;\n    },\n\n    indent: base.indent && function(state, textAfter, line) {\n      return base.indent(state.base, textAfter, line);\n    },\n    electricChars: base.electricChars,\n\n    innerMode: function(state) { return {state: state.base, mode: base}; },\n\n    blankLine: function(state) {\n      var baseToken, overlayToken;\n      if (base.blankLine) baseToken = base.blankLine(state.base);\n      if (overlay.blankLine) overlayToken = overlay.blankLine(state.overlay);\n\n      return overlayToken == null ?\n        baseToken :\n        (combine && baseToken != null ? baseToken + \" \" + overlayToken : overlayToken);\n    }\n  };\n};\n\n});\n","// CodeMirror, copyright (c) by Marijn Haverbeke and others\n// Distributed under an MIT license: https://codemirror.net/5/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\n  CodeMirror.defineSimpleMode = function(name, states) {\n    CodeMirror.defineMode(name, function(config) {\n      return CodeMirror.simpleMode(config, states);\n    });\n  };\n\n  CodeMirror.simpleMode = function(config, states) {\n    ensureState(states, \"start\");\n    var states_ = {}, meta = states.meta || {}, hasIndentation = false;\n    for (var state in states) if (state != meta && states.hasOwnProperty(state)) {\n      var list = states_[state] = [], orig = states[state];\n      for (var i = 0; i < orig.length; i++) {\n        var data = orig[i];\n        list.push(new Rule(data, states));\n        if (data.indent || data.dedent) hasIndentation = true;\n      }\n    }\n    var mode = {\n      startState: function() {\n        return {state: \"start\", pending: null,\n                local: null, localState: null,\n                indent: hasIndentation ? [] : null};\n      },\n      copyState: function(state) {\n        var s = {state: state.state, pending: state.pending,\n                 local: state.local, localState: null,\n                 indent: state.indent && state.indent.slice(0)};\n        if (state.localState)\n          s.localState = CodeMirror.copyState(state.local.mode, state.localState);\n        if (state.stack)\n          s.stack = state.stack.slice(0);\n        for (var pers = state.persistentStates; pers; pers = pers.next)\n          s.persistentStates = {mode: pers.mode,\n                                spec: pers.spec,\n                                state: pers.state == state.localState ? s.localState : CodeMirror.copyState(pers.mode, pers.state),\n                                next: s.persistentStates};\n        return s;\n      },\n      token: tokenFunction(states_, config),\n      innerMode: function(state) { return state.local && {mode: state.local.mode, state: state.localState}; },\n      indent: indentFunction(states_, meta)\n    };\n    if (meta) for (var prop in meta) if (meta.hasOwnProperty(prop))\n      mode[prop] = meta[prop];\n    return mode;\n  };\n\n  function ensureState(states, name) {\n    if (!states.hasOwnProperty(name))\n      throw new Error(\"Undefined state \" + name + \" in simple mode\");\n  }\n\n  function toRegex(val, caret) {\n    if (!val) return /(?:)/;\n    var flags = \"\";\n    if (val instanceof RegExp) {\n      if (val.ignoreCase) flags = \"i\";\n      if (val.unicode) flags += \"u\"\n      val = val.source;\n    } else {\n      val = String(val);\n    }\n    return new RegExp((caret === false ? \"\" : \"^\") + \"(?:\" + val + \")\", flags);\n  }\n\n  function asToken(val) {\n    if (!val) return null;\n    if (val.apply) return val\n    if (typeof val == \"string\") return val.replace(/\\./g, \" \");\n    var result = [];\n    for (var i = 0; i < val.length; i++)\n      result.push(val[i] && val[i].replace(/\\./g, \" \"));\n    return result;\n  }\n\n  function Rule(data, states) {\n    if (data.next || data.push) ensureState(states, data.next || data.push);\n    this.regex = toRegex(data.regex);\n    this.token = asToken(data.token);\n    this.data = data;\n  }\n\n  function tokenFunction(states, config) {\n    return function(stream, state) {\n      if (state.pending) {\n        var pend = state.pending.shift();\n        if (state.pending.length == 0) state.pending = null;\n        stream.pos += pend.text.length;\n        return pend.token;\n      }\n\n      if (state.local) {\n        if (state.local.end && stream.match(state.local.end)) {\n          var tok = state.local.endToken || null;\n          state.local = state.localState = null;\n          return tok;\n        } else {\n          var tok = state.local.mode.token(stream, state.localState), m;\n          if (state.local.endScan && (m = state.local.endScan.exec(stream.current())))\n            stream.pos = stream.start + m.index;\n          return tok;\n        }\n      }\n\n      var curState = states[state.state];\n      for (var i = 0; i < curState.length; i++) {\n        var rule = curState[i];\n        var matches = (!rule.data.sol || stream.sol()) && stream.match(rule.regex);\n        if (matches) {\n          if (rule.data.next) {\n            state.state = rule.data.next;\n          } else if (rule.data.push) {\n            (state.stack || (state.stack = [])).push(state.state);\n            state.state = rule.data.push;\n          } else if (rule.data.pop && state.stack && state.stack.length) {\n            state.state = state.stack.pop();\n          }\n\n          if (rule.data.mode)\n            enterLocalMode(config, state, rule.data.mode, rule.token);\n          if (rule.data.indent)\n            state.indent.push(stream.indentation() + config.indentUnit);\n          if (rule.data.dedent)\n            state.indent.pop();\n          var token = rule.token\n          if (token && token.apply) token = token(matches)\n          if (matches.length > 2 && rule.token && typeof rule.token != \"string\") {\n            for (var j = 2; j < matches.length; j++)\n              if (matches[j])\n                (state.pending || (state.pending = [])).push({text: matches[j], token: rule.token[j - 1]});\n            stream.backUp(matches[0].length - (matches[1] ? matches[1].length : 0));\n            return token[0];\n          } else if (token && token.join) {\n            return token[0];\n          } else {\n            return token;\n          }\n        }\n      }\n      stream.next();\n      return null;\n    };\n  }\n\n  function cmp(a, b) {\n    if (a === b) return true;\n    if (!a || typeof a != \"object\" || !b || typeof b != \"object\") return false;\n    var props = 0;\n    for (var prop in a) if (a.hasOwnProperty(prop)) {\n      if (!b.hasOwnProperty(prop) || !cmp(a[prop], b[prop])) return false;\n      props++;\n    }\n    for (var prop in b) if (b.hasOwnProperty(prop)) props--;\n    return props == 0;\n  }\n\n  function enterLocalMode(config, state, spec, token) {\n    var pers;\n    if (spec.persistent) for (var p = state.persistentStates; p && !pers; p = p.next)\n      if (spec.spec ? cmp(spec.spec, p.spec) : spec.mode == p.mode) pers = p;\n    var mode = pers ? pers.mode : spec.mode || CodeMirror.getMode(config, spec.spec);\n    var lState = pers ? pers.state : CodeMirror.startState(mode);\n    if (spec.persistent && !pers)\n      state.persistentStates = {mode: mode, spec: spec.spec, state: lState, next: state.persistentStates};\n\n    state.localState = lState;\n    state.local = {mode: mode,\n                   end: spec.end && toRegex(spec.end),\n                   endScan: spec.end && spec.forceEnd !== false && toRegex(spec.end, false),\n                   endToken: token && token.join ? token[token.length - 1] : token};\n  }\n\n  function indexOf(val, arr) {\n    for (var i = 0; i < arr.length; i++) if (arr[i] === val) return true;\n  }\n\n  function indentFunction(states, meta) {\n    return function(state, textAfter, line) {\n      if (state.local && state.local.mode.indent)\n        return state.local.mode.indent(state.localState, textAfter, line);\n      if (state.indent == null || state.local || meta.dontIndentStates && indexOf(state.state, meta.dontIndentStates) > -1)\n        return CodeMirror.Pass;\n\n      var pos = state.indent.length - 1, rules = states[state.state];\n      scan: for (;;) {\n        for (var i = 0; i < rules.length; i++) {\n          var rule = rules[i];\n          if (rule.data.dedent && rule.data.dedentIfLineStart !== false) {\n            var m = rule.regex.exec(textAfter);\n            if (m && m[0]) {\n              pos--;\n              if (rule.next || rule.push) rules = states[rule.next || rule.push];\n              textAfter = textAfter.slice(m[0].length);\n              continue scan;\n            }\n          }\n        }\n        break;\n      }\n      return pos < 0 ? 0 : state.indent[pos];\n    };\n  }\n});\n","// CodeMirror, copyright (c) by Marijn Haverbeke and others\n// Distributed under an MIT license: https://codemirror.net/5/LICENSE\n\n/**\n * Link to the project's GitHub page:\n * https://github.com/pickhardt/coffeescript-codemirror-mode\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\nCodeMirror.defineMode(\"coffeescript\", function(conf, parserConf) {\n  var ERRORCLASS = \"error\";\n\n  function wordRegexp(words) {\n    return new RegExp(\"^((\" + words.join(\")|(\") + \"))\\\\b\");\n  }\n\n  var operators = /^(?:->|=>|\\+[+=]?|-[\\-=]?|\\*[\\*=]?|\\/[\\/=]?|[=!]=|<[><]?=?|>>?=?|%=?|&=?|\\|=?|\\^=?|\\~|!|\\?|(or|and|\\|\\||&&|\\?)=)/;\n  var delimiters = /^(?:[()\\[\\]{},:`=;]|\\.\\.?\\.?)/;\n  var identifiers = /^[_A-Za-z$][_A-Za-z$0-9]*/;\n  var atProp = /^@[_A-Za-z$][_A-Za-z$0-9]*/;\n\n  var wordOperators = wordRegexp([\"and\", \"or\", \"not\",\n                                  \"is\", \"isnt\", \"in\",\n                                  \"instanceof\", \"typeof\"]);\n  var indentKeywords = [\"for\", \"while\", \"loop\", \"if\", \"unless\", \"else\",\n                        \"switch\", \"try\", \"catch\", \"finally\", \"class\"];\n  var commonKeywords = [\"break\", \"by\", \"continue\", \"debugger\", \"delete\",\n                        \"do\", \"in\", \"of\", \"new\", \"return\", \"then\",\n                        \"this\", \"@\", \"throw\", \"when\", \"until\", \"extends\"];\n\n  var keywords = wordRegexp(indentKeywords.concat(commonKeywords));\n\n  indentKeywords = wordRegexp(indentKeywords);\n\n\n  var stringPrefixes = /^('{3}|\\\"{3}|['\\\"])/;\n  var regexPrefixes = /^(\\/{3}|\\/)/;\n  var commonConstants = [\"Infinity\", \"NaN\", \"undefined\", \"null\", \"true\", \"false\", \"on\", \"off\", \"yes\", \"no\"];\n  var constants = wordRegexp(commonConstants);\n\n  // Tokenizers\n  function tokenBase(stream, state) {\n    // Handle scope changes\n    if (stream.sol()) {\n      if (state.scope.align === null) state.scope.align = false;\n      var scopeOffset = state.scope.offset;\n      if (stream.eatSpace()) {\n        var lineOffset = stream.indentation();\n        if (lineOffset > scopeOffset && state.scope.type == \"coffee\") {\n          return \"indent\";\n        } else if (lineOffset < scopeOffset) {\n          return \"dedent\";\n        }\n        return null;\n      } else {\n        if (scopeOffset > 0) {\n          dedent(stream, state);\n        }\n      }\n    }\n    if (stream.eatSpace()) {\n      return null;\n    }\n\n    var ch = stream.peek();\n\n    // Handle docco title comment (single line)\n    if (stream.match(\"####\")) {\n      stream.skipToEnd();\n      return \"comment\";\n    }\n\n    // Handle multi line comments\n    if (stream.match(\"###\")) {\n      state.tokenize = longComment;\n      return state.tokenize(stream, state);\n    }\n\n    // Single line comment\n    if (ch === \"#\") {\n      stream.skipToEnd();\n      return \"comment\";\n    }\n\n    // Handle number literals\n    if (stream.match(/^-?[0-9\\.]/, false)) {\n      var floatLiteral = false;\n      // Floats\n      if (stream.match(/^-?\\d*\\.\\d+(e[\\+\\-]?\\d+)?/i)) {\n        floatLiteral = true;\n      }\n      if (stream.match(/^-?\\d+\\.\\d*/)) {\n        floatLiteral = true;\n      }\n      if (stream.match(/^-?\\.\\d+/)) {\n        floatLiteral = true;\n      }\n\n      if (floatLiteral) {\n        // prevent from getting extra . on 1..\n        if (stream.peek() == \".\"){\n          stream.backUp(1);\n        }\n        return \"number\";\n      }\n      // Integers\n      var intLiteral = false;\n      // Hex\n      if (stream.match(/^-?0x[0-9a-f]+/i)) {\n        intLiteral = true;\n      }\n      // Decimal\n      if (stream.match(/^-?[1-9]\\d*(e[\\+\\-]?\\d+)?/)) {\n        intLiteral = true;\n      }\n      // Zero by itself with no other piece of number.\n      if (stream.match(/^-?0(?![\\dx])/i)) {\n        intLiteral = true;\n      }\n      if (intLiteral) {\n        return \"number\";\n      }\n    }\n\n    // Handle strings\n    if (stream.match(stringPrefixes)) {\n      state.tokenize = tokenFactory(stream.current(), false, \"string\");\n      return state.tokenize(stream, state);\n    }\n    // Handle regex literals\n    if (stream.match(regexPrefixes)) {\n      if (stream.current() != \"/\" || stream.match(/^.*\\//, false)) { // prevent highlight of division\n        state.tokenize = tokenFactory(stream.current(), true, \"string-2\");\n        return state.tokenize(stream, state);\n      } else {\n        stream.backUp(1);\n      }\n    }\n\n\n\n    // Handle operators and delimiters\n    if (stream.match(operators) || stream.match(wordOperators)) {\n      return \"operator\";\n    }\n    if (stream.match(delimiters)) {\n      return \"punctuation\";\n    }\n\n    if (stream.match(constants)) {\n      return \"atom\";\n    }\n\n    if (stream.match(atProp) || state.prop && stream.match(identifiers)) {\n      return \"property\";\n    }\n\n    if (stream.match(keywords)) {\n      return \"keyword\";\n    }\n\n    if (stream.match(identifiers)) {\n      return \"variable\";\n    }\n\n    // Handle non-detected items\n    stream.next();\n    return ERRORCLASS;\n  }\n\n  function tokenFactory(delimiter, singleline, outclass) {\n    return function(stream, state) {\n      while (!stream.eol()) {\n        stream.eatWhile(/[^'\"\\/\\\\]/);\n        if (stream.eat(\"\\\\\")) {\n          stream.next();\n          if (singleline && stream.eol()) {\n            return outclass;\n          }\n        } else if (stream.match(delimiter)) {\n          state.tokenize = tokenBase;\n          return outclass;\n        } else {\n          stream.eat(/['\"\\/]/);\n        }\n      }\n      if (singleline) {\n        if (parserConf.singleLineStringErrors) {\n          outclass = ERRORCLASS;\n        } else {\n          state.tokenize = tokenBase;\n        }\n      }\n      return outclass;\n    };\n  }\n\n  function longComment(stream, state) {\n    while (!stream.eol()) {\n      stream.eatWhile(/[^#]/);\n      if (stream.match(\"###\")) {\n        state.tokenize = tokenBase;\n        break;\n      }\n      stream.eatWhile(\"#\");\n    }\n    return \"comment\";\n  }\n\n  function indent(stream, state, type) {\n    type = type || \"coffee\";\n    var offset = 0, align = false, alignOffset = null;\n    for (var scope = state.scope; scope; scope = scope.prev) {\n      if (scope.type === \"coffee\" || scope.type == \"}\") {\n        offset = scope.offset + conf.indentUnit;\n        break;\n      }\n    }\n    if (type !== \"coffee\") {\n      align = null;\n      alignOffset = stream.column() + stream.current().length;\n    } else if (state.scope.align) {\n      state.scope.align = false;\n    }\n    state.scope = {\n      offset: offset,\n      type: type,\n      prev: state.scope,\n      align: align,\n      alignOffset: alignOffset\n    };\n  }\n\n  function dedent(stream, state) {\n    if (!state.scope.prev) return;\n    if (state.scope.type === \"coffee\") {\n      var _indent = stream.indentation();\n      var matched = false;\n      for (var scope = state.scope; scope; scope = scope.prev) {\n        if (_indent === scope.offset) {\n          matched = true;\n          break;\n        }\n      }\n      if (!matched) {\n        return true;\n      }\n      while (state.scope.prev && state.scope.offset !== _indent) {\n        state.scope = state.scope.prev;\n      }\n      return false;\n    } else {\n      state.scope = state.scope.prev;\n      return false;\n    }\n  }\n\n  function tokenLexer(stream, state) {\n    var style = state.tokenize(stream, state);\n    var current = stream.current();\n\n    // Handle scope changes.\n    if (current === \"return\") {\n      state.dedent = true;\n    }\n    if (((current === \"->\" || current === \"=>\") && stream.eol())\n        || style === \"indent\") {\n      indent(stream, state);\n    }\n    var delimiter_index = \"[({\".indexOf(current);\n    if (delimiter_index !== -1) {\n      indent(stream, state, \"])}\".slice(delimiter_index, delimiter_index+1));\n    }\n    if (indentKeywords.exec(current)){\n      indent(stream, state);\n    }\n    if (current == \"then\"){\n      dedent(stream, state);\n    }\n\n\n    if (style === \"dedent\") {\n      if (dedent(stream, state)) {\n        return ERRORCLASS;\n      }\n    }\n    delimiter_index = \"])}\".indexOf(current);\n    if (delimiter_index !== -1) {\n      while (state.scope.type == \"coffee\" && state.scope.prev)\n        state.scope = state.scope.prev;\n      if (state.scope.type == current)\n        state.scope = state.scope.prev;\n    }\n    if (state.dedent && stream.eol()) {\n      if (state.scope.type == \"coffee\" && state.scope.prev)\n        state.scope = state.scope.prev;\n      state.dedent = false;\n    }\n\n    return style;\n  }\n\n  var external = {\n    startState: function(basecolumn) {\n      return {\n        tokenize: tokenBase,\n        scope: {offset:basecolumn || 0, type:\"coffee\", prev: null, align: false},\n        prop: false,\n        dedent: 0\n      };\n    },\n\n    token: function(stream, state) {\n      var fillAlign = state.scope.align === null && state.scope;\n      if (fillAlign && stream.sol()) fillAlign.align = false;\n\n      var style = tokenLexer(stream, state);\n      if (style && style != \"comment\") {\n        if (fillAlign) fillAlign.align = true;\n        state.prop = style == \"punctuation\" && stream.current() == \".\"\n      }\n\n      return style;\n    },\n\n    indent: function(state, text) {\n      if (state.tokenize != tokenBase) return 0;\n      var scope = state.scope;\n      var closer = text && \"])}\".indexOf(text.charAt(0)) > -1;\n      if (closer) while (scope.type == \"coffee\" && scope.prev) scope = scope.prev;\n      var closes = closer && scope.type === text.charAt(0);\n      if (scope.align)\n        return scope.alignOffset - (closes ? 1 : 0);\n      else\n        return (closes ? scope.prev : scope).offset;\n    },\n\n    lineComment: \"#\",\n    fold: \"indent\"\n  };\n  return external;\n});\n\n// IANA registered media type\n// https://www.iana.org/assignments/media-types/\nCodeMirror.defineMIME(\"application/vnd.coffeescript\", \"coffeescript\");\n\nCodeMirror.defineMIME(\"text/x-coffeescript\", \"coffeescript\");\nCodeMirror.defineMIME(\"text/coffeescript\", \"coffeescript\");\n\n});\n","// CodeMirror, copyright (c) by Marijn Haverbeke and others\n// Distributed under an MIT license: https://codemirror.net/5/LICENSE\n\n(function(mod) {\n  if (typeof exports == \"object\" && typeof module == \"object\") // CommonJS\n    mod(require(\"../../lib/codemirror\"), require(\"../../addon/mode/simple\"), require(\"../../addon/mode/multiplex\"));\n  else if (typeof define == \"function\" && define.amd) // AMD\n    define([\"../../lib/codemirror\", \"../../addon/mode/simple\", \"../../addon/mode/multiplex\"], mod);\n  else // Plain browser env\n    mod(CodeMirror);\n})(function(CodeMirror) {\n  \"use strict\";\n\n  CodeMirror.defineSimpleMode(\"handlebars-tags\", {\n    start: [\n      { regex: /\\{\\{\\{/, push: \"handlebars_raw\", token: \"tag\" },\n      { regex: /\\{\\{!--/, push: \"dash_comment\", token: \"comment\" },\n      { regex: /\\{\\{!/,   push: \"comment\", token: \"comment\" },\n      { regex: /\\{\\{/,    push: \"handlebars\", token: \"tag\" }\n    ],\n    handlebars_raw: [\n      { regex: /\\}\\}\\}/, pop: true, token: \"tag\" },\n    ],\n    handlebars: [\n      { regex: /\\}\\}/, pop: true, token: \"tag\" },\n\n      // Double and single quotes\n      { regex: /\"(?:[^\\\\\"]|\\\\.)*\"?/, token: \"string\" },\n      { regex: /'(?:[^\\\\']|\\\\.)*'?/, token: \"string\" },\n\n      // Handlebars keywords\n      { regex: />|[#\\/]([A-Za-z_]\\w*)/, token: \"keyword\" },\n      { regex: /(?:else|this)\\b/, token: \"keyword\" },\n\n      // Numeral\n      { regex: /\\d+/i, token: \"number\" },\n\n      // Atoms like = and .\n      { regex: /=|~|@|true|false/, token: \"atom\" },\n\n      // Paths\n      { regex: /(?:\\.\\.\\/)*(?:[A-Za-z_][\\w\\.]*)+/, token: \"variable-2\" }\n    ],\n    dash_comment: [\n      { regex: /--\\}\\}/, pop: true, token: \"comment\" },\n\n      // Commented code\n      { regex: /./, token: \"comment\"}\n    ],\n    comment: [\n      { regex: /\\}\\}/, pop: true, token: \"comment\" },\n      { regex: /./, token: \"comment\" }\n    ],\n    meta: {\n      blockCommentStart: \"{{--\",\n      blockCommentEnd: \"--}}\"\n    }\n  });\n\n  CodeMirror.defineMode(\"handlebars\", function(config, parserConfig) {\n    var handlebars = CodeMirror.getMode(config, \"handlebars-tags\");\n    if (!parserConfig || !parserConfig.base) return handlebars;\n    return CodeMirror.multiplexingMode(\n      CodeMirror.getMode(config, parserConfig.base),\n      {open: \"{{\", close: /\\}\\}\\}?/, mode: handlebars, parseDelimiters: true}\n    );\n  });\n\n  CodeMirror.defineMIME(\"text/x-handlebars-template\", \"handlebars\");\n});\n","// CodeMirror, copyright (c) by Marijn Haverbeke and others\n// Distributed under an MIT license: https://codemirror.net/5/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\nCodeMirror.defineMode(\"haskell\", function(_config, modeConfig) {\n\n  function switchState(source, setState, f) {\n    setState(f);\n    return f(source, setState);\n  }\n\n  // These should all be Unicode extended, as per the Haskell 2010 report\n  var smallRE = /[a-z_]/;\n  var largeRE = /[A-Z]/;\n  var digitRE = /\\d/;\n  var hexitRE = /[0-9A-Fa-f]/;\n  var octitRE = /[0-7]/;\n  var idRE = /[a-z_A-Z0-9'\\xa1-\\uffff]/;\n  var symbolRE = /[-!#$%&*+.\\/<=>?@\\\\^|~:]/;\n  var specialRE = /[(),;[\\]`{}]/;\n  var whiteCharRE = /[ \\t\\v\\f]/; // newlines are handled in tokenizer\n\n  function normal(source, setState) {\n    if (source.eatWhile(whiteCharRE)) {\n      return null;\n    }\n\n    var ch = source.next();\n    if (specialRE.test(ch)) {\n      if (ch == '{' && source.eat('-')) {\n        var t = \"comment\";\n        if (source.eat('#')) {\n          t = \"meta\";\n        }\n        return switchState(source, setState, ncomment(t, 1));\n      }\n      return null;\n    }\n\n    if (ch == '\\'') {\n      if (source.eat('\\\\')) {\n        source.next();  // should handle other escapes here\n      }\n      else {\n        source.next();\n      }\n      if (source.eat('\\'')) {\n        return \"string\";\n      }\n      return \"string error\";\n    }\n\n    if (ch == '\"') {\n      return switchState(source, setState, stringLiteral);\n    }\n\n    if (largeRE.test(ch)) {\n      source.eatWhile(idRE);\n      if (source.eat('.')) {\n        return \"qualifier\";\n      }\n      return \"variable-2\";\n    }\n\n    if (smallRE.test(ch)) {\n      source.eatWhile(idRE);\n      return \"variable\";\n    }\n\n    if (digitRE.test(ch)) {\n      if (ch == '0') {\n        if (source.eat(/[xX]/)) {\n          source.eatWhile(hexitRE); // should require at least 1\n          return \"integer\";\n        }\n        if (source.eat(/[oO]/)) {\n          source.eatWhile(octitRE); // should require at least 1\n          return \"number\";\n        }\n      }\n      source.eatWhile(digitRE);\n      var t = \"number\";\n      if (source.match(/^\\.\\d+/)) {\n        t = \"number\";\n      }\n      if (source.eat(/[eE]/)) {\n        t = \"number\";\n        source.eat(/[-+]/);\n        source.eatWhile(digitRE); // should require at least 1\n      }\n      return t;\n    }\n\n    if (ch == \".\" && source.eat(\".\"))\n      return \"keyword\";\n\n    if (symbolRE.test(ch)) {\n      if (ch == '-' && source.eat(/-/)) {\n        source.eatWhile(/-/);\n        if (!source.eat(symbolRE)) {\n          source.skipToEnd();\n          return \"comment\";\n        }\n      }\n      var t = \"variable\";\n      if (ch == ':') {\n        t = \"variable-2\";\n      }\n      source.eatWhile(symbolRE);\n      return t;\n    }\n\n    return \"error\";\n  }\n\n  function ncomment(type, nest) {\n    if (nest == 0) {\n      return normal;\n    }\n    return function(source, setState) {\n      var currNest = nest;\n      while (!source.eol()) {\n        var ch = source.next();\n        if (ch == '{' && source.eat('-')) {\n          ++currNest;\n        }\n        else if (ch == '-' && source.eat('}')) {\n          --currNest;\n          if (currNest == 0) {\n            setState(normal);\n            return type;\n          }\n        }\n      }\n      setState(ncomment(type, currNest));\n      return type;\n    };\n  }\n\n  function stringLiteral(source, setState) {\n    while (!source.eol()) {\n      var ch = source.next();\n      if (ch == '\"') {\n        setState(normal);\n        return \"string\";\n      }\n      if (ch == '\\\\') {\n        if (source.eol() || source.eat(whiteCharRE)) {\n          setState(stringGap);\n          return \"string\";\n        }\n        if (source.eat('&')) {\n        }\n        else {\n          source.next(); // should handle other escapes here\n        }\n      }\n    }\n    setState(normal);\n    return \"string error\";\n  }\n\n  function stringGap(source, setState) {\n    if (source.eat('\\\\')) {\n      return switchState(source, setState, stringLiteral);\n    }\n    source.next();\n    setState(normal);\n    return \"error\";\n  }\n\n\n  var wellKnownWords = (function() {\n    var wkw = {};\n    function setType(t) {\n      return function () {\n        for (var i = 0; i < arguments.length; i++)\n          wkw[arguments[i]] = t;\n      };\n    }\n\n    setType(\"keyword\")(\n      \"case\", \"class\", \"data\", \"default\", \"deriving\", \"do\", \"else\", \"foreign\",\n      \"if\", \"import\", \"in\", \"infix\", \"infixl\", \"infixr\", \"instance\", \"let\",\n      \"module\", \"newtype\", \"of\", \"then\", \"type\", \"where\", \"_\");\n\n    setType(\"keyword\")(\n      \"\\.\\.\", \":\", \"::\", \"=\", \"\\\\\", \"<-\", \"->\", \"@\", \"~\", \"=>\");\n\n    setType(\"builtin\")(\n      \"!!\", \"$!\", \"$\", \"&&\", \"+\", \"++\", \"-\", \".\", \"/\", \"/=\", \"<\", \"<*\", \"<=\",\n      \"<$>\", \"<*>\", \"=<<\", \"==\", \">\", \">=\", \">>\", \">>=\", \"^\", \"^^\", \"||\", \"*\",\n      \"*>\", \"**\");\n\n    setType(\"builtin\")(\n      \"Applicative\", \"Bool\", \"Bounded\", \"Char\", \"Double\", \"EQ\", \"Either\", \"Enum\",\n      \"Eq\", \"False\", \"FilePath\", \"Float\", \"Floating\", \"Fractional\", \"Functor\",\n      \"GT\", \"IO\", \"IOError\", \"Int\", \"Integer\", \"Integral\", \"Just\", \"LT\", \"Left\",\n      \"Maybe\", \"Monad\", \"Nothing\", \"Num\", \"Ord\", \"Ordering\", \"Rational\", \"Read\",\n      \"ReadS\", \"Real\", \"RealFloat\", \"RealFrac\", \"Right\", \"Show\", \"ShowS\",\n      \"String\", \"True\");\n\n    setType(\"builtin\")(\n      \"abs\", \"acos\", \"acosh\", \"all\", \"and\", \"any\", \"appendFile\", \"asTypeOf\",\n      \"asin\", \"asinh\", \"atan\", \"atan2\", \"atanh\", \"break\", \"catch\", \"ceiling\",\n      \"compare\", \"concat\", \"concatMap\", \"const\", \"cos\", \"cosh\", \"curry\",\n      \"cycle\", \"decodeFloat\", \"div\", \"divMod\", \"drop\", \"dropWhile\", \"either\",\n      \"elem\", \"encodeFloat\", \"enumFrom\", \"enumFromThen\", \"enumFromThenTo\",\n      \"enumFromTo\", \"error\", \"even\", \"exp\", \"exponent\", \"fail\", \"filter\",\n      \"flip\", \"floatDigits\", \"floatRadix\", \"floatRange\", \"floor\", \"fmap\",\n      \"foldl\", \"foldl1\", \"foldr\", \"foldr1\", \"fromEnum\", \"fromInteger\",\n      \"fromIntegral\", \"fromRational\", \"fst\", \"gcd\", \"getChar\", \"getContents\",\n      \"getLine\", \"head\", \"id\", \"init\", \"interact\", \"ioError\", \"isDenormalized\",\n      \"isIEEE\", \"isInfinite\", \"isNaN\", \"isNegativeZero\", \"iterate\", \"last\",\n      \"lcm\", \"length\", \"lex\", \"lines\", \"log\", \"logBase\", \"lookup\", \"map\",\n      \"mapM\", \"mapM_\", \"max\", \"maxBound\", \"maximum\", \"maybe\", \"min\", \"minBound\",\n      \"minimum\", \"mod\", \"negate\", \"not\", \"notElem\", \"null\", \"odd\", \"or\",\n      \"otherwise\", \"pi\", \"pred\", \"print\", \"product\", \"properFraction\", \"pure\",\n      \"putChar\", \"putStr\", \"putStrLn\", \"quot\", \"quotRem\", \"read\", \"readFile\",\n      \"readIO\", \"readList\", \"readLn\", \"readParen\", \"reads\", \"readsPrec\",\n      \"realToFrac\", \"recip\", \"rem\", \"repeat\", \"replicate\", \"return\", \"reverse\",\n      \"round\", \"scaleFloat\", \"scanl\", \"scanl1\", \"scanr\", \"scanr1\", \"seq\",\n      \"sequence\", \"sequence_\", \"show\", \"showChar\", \"showList\", \"showParen\",\n      \"showString\", \"shows\", \"showsPrec\", \"significand\", \"signum\", \"sin\",\n      \"sinh\", \"snd\", \"span\", \"splitAt\", \"sqrt\", \"subtract\", \"succ\", \"sum\",\n      \"tail\", \"take\", \"takeWhile\", \"tan\", \"tanh\", \"toEnum\", \"toInteger\",\n      \"toRational\", \"truncate\", \"uncurry\", \"undefined\", \"unlines\", \"until\",\n      \"unwords\", \"unzip\", \"unzip3\", \"userError\", \"words\", \"writeFile\", \"zip\",\n      \"zip3\", \"zipWith\", \"zipWith3\");\n\n    var override = modeConfig.overrideKeywords;\n    if (override) for (var word in override) if (override.hasOwnProperty(word))\n      wkw[word] = override[word];\n\n    return wkw;\n  })();\n\n\n\n  return {\n    startState: function ()  { return { f: normal }; },\n    copyState:  function (s) { return { f: s.f }; },\n\n    token: function(stream, state) {\n      var t = state.f(stream, function(s) { state.f = s; });\n      var w = stream.current();\n      return wellKnownWords.hasOwnProperty(w) ? wellKnownWords[w] : t;\n    },\n\n    blockCommentStart: \"{-\",\n    blockCommentEnd: \"-}\",\n    lineComment: \"--\"\n  };\n\n});\n\nCodeMirror.defineMIME(\"text/x-haskell\", \"haskell\");\n\n});\n","// CodeMirror, copyright (c) by Marijn Haverbeke and others\n// Distributed under an MIT license: https://codemirror.net/5/LICENSE\n\n(function(mod) {\n  if (typeof exports == \"object\" && typeof module == \"object\") // CommonJS\n    mod(require(\"../../lib/codemirror\"), require(\"../javascript/javascript\"), require(\"../css/css\"), require(\"../htmlmixed/htmlmixed\"));\n  else if (typeof define == \"function\" && define.amd) // AMD\n    define([\"../../lib/codemirror\", \"../javascript/javascript\", \"../css/css\", \"../htmlmixed/htmlmixed\"], mod);\n  else // Plain browser env\n    mod(CodeMirror);\n})(function(CodeMirror) {\n\"use strict\";\n\nCodeMirror.defineMode(\"pug\", function (config) {\n  // token types\n  var KEYWORD = 'keyword';\n  var DOCTYPE = 'meta';\n  var ID = 'builtin';\n  var CLASS = 'qualifier';\n\n  var ATTRS_NEST = {\n    '{': '}',\n    '(': ')',\n    '[': ']'\n  };\n\n  var jsMode = CodeMirror.getMode(config, 'javascript');\n\n  function State() {\n    this.javaScriptLine = false;\n    this.javaScriptLineExcludesColon = false;\n\n    this.javaScriptArguments = false;\n    this.javaScriptArgumentsDepth = 0;\n\n    this.isInterpolating = false;\n    this.interpolationNesting = 0;\n\n    this.jsState = CodeMirror.startState(jsMode);\n\n    this.restOfLine = '';\n\n    this.isIncludeFiltered = false;\n    this.isEach = false;\n\n    this.lastTag = '';\n    this.scriptType = '';\n\n    // Attributes Mode\n    this.isAttrs = false;\n    this.attrsNest = [];\n    this.inAttributeName = true;\n    this.attributeIsType = false;\n    this.attrValue = '';\n\n    // Indented Mode\n    this.indentOf = Infinity;\n    this.indentToken = '';\n\n    this.innerMode = null;\n    this.innerState = null;\n\n    this.innerModeForLine = false;\n  }\n  /**\n   * Safely copy a state\n   *\n   * @return {State}\n   */\n  State.prototype.copy = function () {\n    var res = new State();\n    res.javaScriptLine = this.javaScriptLine;\n    res.javaScriptLineExcludesColon = this.javaScriptLineExcludesColon;\n    res.javaScriptArguments = this.javaScriptArguments;\n    res.javaScriptArgumentsDepth = this.javaScriptArgumentsDepth;\n    res.isInterpolating = this.isInterpolating;\n    res.interpolationNesting = this.interpolationNesting;\n\n    res.jsState = CodeMirror.copyState(jsMode, this.jsState);\n\n    res.innerMode = this.innerMode;\n    if (this.innerMode && this.innerState) {\n      res.innerState = CodeMirror.copyState(this.innerMode, this.innerState);\n    }\n\n    res.restOfLine = this.restOfLine;\n\n    res.isIncludeFiltered = this.isIncludeFiltered;\n    res.isEach = this.isEach;\n    res.lastTag = this.lastTag;\n    res.scriptType = this.scriptType;\n    res.isAttrs = this.isAttrs;\n    res.attrsNest = this.attrsNest.slice();\n    res.inAttributeName = this.inAttributeName;\n    res.attributeIsType = this.attributeIsType;\n    res.attrValue = this.attrValue;\n    res.indentOf = this.indentOf;\n    res.indentToken = this.indentToken;\n\n    res.innerModeForLine = this.innerModeForLine;\n\n    return res;\n  };\n\n  function javaScript(stream, state) {\n    if (stream.sol()) {\n      // if javaScriptLine was set at end of line, ignore it\n      state.javaScriptLine = false;\n      state.javaScriptLineExcludesColon = false;\n    }\n    if (state.javaScriptLine) {\n      if (state.javaScriptLineExcludesColon && stream.peek() === ':') {\n        state.javaScriptLine = false;\n        state.javaScriptLineExcludesColon = false;\n        return;\n      }\n      var tok = jsMode.token(stream, state.jsState);\n      if (stream.eol()) state.javaScriptLine = false;\n      return tok || true;\n    }\n  }\n  function javaScriptArguments(stream, state) {\n    if (state.javaScriptArguments) {\n      if (state.javaScriptArgumentsDepth === 0 && stream.peek() !== '(') {\n        state.javaScriptArguments = false;\n        return;\n      }\n      if (stream.peek() === '(') {\n        state.javaScriptArgumentsDepth++;\n      } else if (stream.peek() === ')') {\n        state.javaScriptArgumentsDepth--;\n      }\n      if (state.javaScriptArgumentsDepth === 0) {\n        state.javaScriptArguments = false;\n        return;\n      }\n\n      var tok = jsMode.token(stream, state.jsState);\n      return tok || true;\n    }\n  }\n\n  function yieldStatement(stream) {\n    if (stream.match(/^yield\\b/)) {\n        return 'keyword';\n    }\n  }\n\n  function doctype(stream) {\n    if (stream.match(/^(?:doctype) *([^\\n]+)?/)) {\n        return DOCTYPE;\n    }\n  }\n\n  function interpolation(stream, state) {\n    if (stream.match('#{')) {\n      state.isInterpolating = true;\n      state.interpolationNesting = 0;\n      return 'punctuation';\n    }\n  }\n\n  function interpolationContinued(stream, state) {\n    if (state.isInterpolating) {\n      if (stream.peek() === '}') {\n        state.interpolationNesting--;\n        if (state.interpolationNesting < 0) {\n          stream.next();\n          state.isInterpolating = false;\n          return 'punctuation';\n        }\n      } else if (stream.peek() === '{') {\n        state.interpolationNesting++;\n      }\n      return jsMode.token(stream, state.jsState) || true;\n    }\n  }\n\n  function caseStatement(stream, state) {\n    if (stream.match(/^case\\b/)) {\n      state.javaScriptLine = true;\n      return KEYWORD;\n    }\n  }\n\n  function when(stream, state) {\n    if (stream.match(/^when\\b/)) {\n      state.javaScriptLine = true;\n      state.javaScriptLineExcludesColon = true;\n      return KEYWORD;\n    }\n  }\n\n  function defaultStatement(stream) {\n    if (stream.match(/^default\\b/)) {\n      return KEYWORD;\n    }\n  }\n\n  function extendsStatement(stream, state) {\n    if (stream.match(/^extends?\\b/)) {\n      state.restOfLine = 'string';\n      return KEYWORD;\n    }\n  }\n\n  function append(stream, state) {\n    if (stream.match(/^append\\b/)) {\n      state.restOfLine = 'variable';\n      return KEYWORD;\n    }\n  }\n  function prepend(stream, state) {\n    if (stream.match(/^prepend\\b/)) {\n      state.restOfLine = 'variable';\n      return KEYWORD;\n    }\n  }\n  function block(stream, state) {\n    if (stream.match(/^block\\b *(?:(prepend|append)\\b)?/)) {\n      state.restOfLine = 'variable';\n      return KEYWORD;\n    }\n  }\n\n  function include(stream, state) {\n    if (stream.match(/^include\\b/)) {\n      state.restOfLine = 'string';\n      return KEYWORD;\n    }\n  }\n\n  function includeFiltered(stream, state) {\n    if (stream.match(/^include:([a-zA-Z0-9\\-]+)/, false) && stream.match('include')) {\n      state.isIncludeFiltered = true;\n      return KEYWORD;\n    }\n  }\n\n  function includeFilteredContinued(stream, state) {\n    if (state.isIncludeFiltered) {\n      var tok = filter(stream, state);\n      state.isIncludeFiltered = false;\n      state.restOfLine = 'string';\n      return tok;\n    }\n  }\n\n  function mixin(stream, state) {\n    if (stream.match(/^mixin\\b/)) {\n      state.javaScriptLine = true;\n      return KEYWORD;\n    }\n  }\n\n  function call(stream, state) {\n    if (stream.match(/^\\+([-\\w]+)/)) {\n      if (!stream.match(/^\\( *[-\\w]+ *=/, false)) {\n        state.javaScriptArguments = true;\n        state.javaScriptArgumentsDepth = 0;\n      }\n      return 'variable';\n    }\n    if (stream.match('+#{', false)) {\n      stream.next();\n      state.mixinCallAfter = true;\n      return interpolation(stream, state);\n    }\n  }\n  function callArguments(stream, state) {\n    if (state.mixinCallAfter) {\n      state.mixinCallAfter = false;\n      if (!stream.match(/^\\( *[-\\w]+ *=/, false)) {\n        state.javaScriptArguments = true;\n        state.javaScriptArgumentsDepth = 0;\n      }\n      return true;\n    }\n  }\n\n  function conditional(stream, state) {\n    if (stream.match(/^(if|unless|else if|else)\\b/)) {\n      state.javaScriptLine = true;\n      return KEYWORD;\n    }\n  }\n\n  function each(stream, state) {\n    if (stream.match(/^(- *)?(each|for)\\b/)) {\n      state.isEach = true;\n      return KEYWORD;\n    }\n  }\n  function eachContinued(stream, state) {\n    if (state.isEach) {\n      if (stream.match(/^ in\\b/)) {\n        state.javaScriptLine = true;\n        state.isEach = false;\n        return KEYWORD;\n      } else if (stream.sol() || stream.eol()) {\n        state.isEach = false;\n      } else if (stream.next()) {\n        while (!stream.match(/^ in\\b/, false) && stream.next());\n        return 'variable';\n      }\n    }\n  }\n\n  function whileStatement(stream, state) {\n    if (stream.match(/^while\\b/)) {\n      state.javaScriptLine = true;\n      return KEYWORD;\n    }\n  }\n\n  function tag(stream, state) {\n    var captures;\n    if (captures = stream.match(/^(\\w(?:[-:\\w]*\\w)?)\\/?/)) {\n      state.lastTag = captures[1].toLowerCase();\n      if (state.lastTag === 'script') {\n        state.scriptType = 'application/javascript';\n      }\n      return 'tag';\n    }\n  }\n\n  function filter(stream, state) {\n    if (stream.match(/^:([\\w\\-]+)/)) {\n      var innerMode;\n      if (config && config.innerModes) {\n        innerMode = config.innerModes(stream.current().substring(1));\n      }\n      if (!innerMode) {\n        innerMode = stream.current().substring(1);\n      }\n      if (typeof innerMode === 'string') {\n        innerMode = CodeMirror.getMode(config, innerMode);\n      }\n      setInnerMode(stream, state, innerMode);\n      return 'atom';\n    }\n  }\n\n  function code(stream, state) {\n    if (stream.match(/^(!?=|-)/)) {\n      state.javaScriptLine = true;\n      return 'punctuation';\n    }\n  }\n\n  function id(stream) {\n    if (stream.match(/^#([\\w-]+)/)) {\n      return ID;\n    }\n  }\n\n  function className(stream) {\n    if (stream.match(/^\\.([\\w-]+)/)) {\n      return CLASS;\n    }\n  }\n\n  function attrs(stream, state) {\n    if (stream.peek() == '(') {\n      stream.next();\n      state.isAttrs = true;\n      state.attrsNest = [];\n      state.inAttributeName = true;\n      state.attrValue = '';\n      state.attributeIsType = false;\n      return 'punctuation';\n    }\n  }\n\n  function attrsContinued(stream, state) {\n    if (state.isAttrs) {\n      if (ATTRS_NEST[stream.peek()]) {\n        state.attrsNest.push(ATTRS_NEST[stream.peek()]);\n      }\n      if (state.attrsNest[state.attrsNest.length - 1] === stream.peek()) {\n        state.attrsNest.pop();\n      } else  if (stream.eat(')')) {\n        state.isAttrs = false;\n        return 'punctuation';\n      }\n      if (state.inAttributeName && stream.match(/^[^=,\\)!]+/)) {\n        if (stream.peek() === '=' || stream.peek() === '!') {\n          state.inAttributeName = false;\n          state.jsState = CodeMirror.startState(jsMode);\n          if (state.lastTag === 'script' && stream.current().trim().toLowerCase() === 'type') {\n            state.attributeIsType = true;\n          } else {\n            state.attributeIsType = false;\n          }\n        }\n        return 'attribute';\n      }\n\n      var tok = jsMode.token(stream, state.jsState);\n      if (state.attributeIsType && tok === 'string') {\n        state.scriptType = stream.current().toString();\n      }\n      if (state.attrsNest.length === 0 && (tok === 'string' || tok === 'variable' || tok === 'keyword')) {\n        try {\n          Function('', 'var x ' + state.attrValue.replace(/,\\s*$/, '').replace(/^!/, ''));\n          state.inAttributeName = true;\n          state.attrValue = '';\n          stream.backUp(stream.current().length);\n          return attrsContinued(stream, state);\n        } catch (ex) {\n          //not the end of an attribute\n        }\n      }\n      state.attrValue += stream.current();\n      return tok || true;\n    }\n  }\n\n  function attributesBlock(stream, state) {\n    if (stream.match(/^&attributes\\b/)) {\n      state.javaScriptArguments = true;\n      state.javaScriptArgumentsDepth = 0;\n      return 'keyword';\n    }\n  }\n\n  function indent(stream) {\n    if (stream.sol() && stream.eatSpace()) {\n      return 'indent';\n    }\n  }\n\n  function comment(stream, state) {\n    if (stream.match(/^ *\\/\\/(-)?([^\\n]*)/)) {\n      state.indentOf = stream.indentation();\n      state.indentToken = 'comment';\n      return 'comment';\n    }\n  }\n\n  function colon(stream) {\n    if (stream.match(/^: */)) {\n      return 'colon';\n    }\n  }\n\n  function text(stream, state) {\n    if (stream.match(/^(?:\\| ?| )([^\\n]+)/)) {\n      return 'string';\n    }\n    if (stream.match(/^(<[^\\n]*)/, false)) {\n      // html string\n      setInnerMode(stream, state, 'htmlmixed');\n      state.innerModeForLine = true;\n      return innerMode(stream, state, true);\n    }\n  }\n\n  function dot(stream, state) {\n    if (stream.eat('.')) {\n      var innerMode = null;\n      if (state.lastTag === 'script' && state.scriptType.toLowerCase().indexOf('javascript') != -1) {\n        innerMode = state.scriptType.toLowerCase().replace(/\"|'/g, '');\n      } else if (state.lastTag === 'style') {\n        innerMode = 'css';\n      }\n      setInnerMode(stream, state, innerMode);\n      return 'dot';\n    }\n  }\n\n  function fail(stream) {\n    stream.next();\n    return null;\n  }\n\n\n  function setInnerMode(stream, state, mode) {\n    mode = CodeMirror.mimeModes[mode] || mode;\n    mode = config.innerModes ? config.innerModes(mode) || mode : mode;\n    mode = CodeMirror.mimeModes[mode] || mode;\n    mode = CodeMirror.getMode(config, mode);\n    state.indentOf = stream.indentation();\n\n    if (mode && mode.name !== 'null') {\n      state.innerMode = mode;\n    } else {\n      state.indentToken = 'string';\n    }\n  }\n  function innerMode(stream, state, force) {\n    if (stream.indentation() > state.indentOf || (state.innerModeForLine && !stream.sol()) || force) {\n      if (state.innerMode) {\n        if (!state.innerState) {\n          state.innerState = state.innerMode.startState ? CodeMirror.startState(state.innerMode, stream.indentation()) : {};\n        }\n        return stream.hideFirstChars(state.indentOf + 2, function () {\n          return state.innerMode.token(stream, state.innerState) || true;\n        });\n      } else {\n        stream.skipToEnd();\n        return state.indentToken;\n      }\n    } else if (stream.sol()) {\n      state.indentOf = Infinity;\n      state.indentToken = null;\n      state.innerMode = null;\n      state.innerState = null;\n    }\n  }\n  function restOfLine(stream, state) {\n    if (stream.sol()) {\n      // if restOfLine was set at end of line, ignore it\n      state.restOfLine = '';\n    }\n    if (state.restOfLine) {\n      stream.skipToEnd();\n      var tok = state.restOfLine;\n      state.restOfLine = '';\n      return tok;\n    }\n  }\n\n\n  function startState() {\n    return new State();\n  }\n  function copyState(state) {\n    return state.copy();\n  }\n  /**\n   * Get the next token in the stream\n   *\n   * @param {Stream} stream\n   * @param {State} state\n   */\n  function nextToken(stream, state) {\n    var tok = innerMode(stream, state)\n      || restOfLine(stream, state)\n      || interpolationContinued(stream, state)\n      || includeFilteredContinued(stream, state)\n      || eachContinued(stream, state)\n      || attrsContinued(stream, state)\n      || javaScript(stream, state)\n      || javaScriptArguments(stream, state)\n      || callArguments(stream, state)\n\n      || yieldStatement(stream)\n      || doctype(stream)\n      || interpolation(stream, state)\n      || caseStatement(stream, state)\n      || when(stream, state)\n      || defaultStatement(stream)\n      || extendsStatement(stream, state)\n      || append(stream, state)\n      || prepend(stream, state)\n      || block(stream, state)\n      || include(stream, state)\n      || includeFiltered(stream, state)\n      || mixin(stream, state)\n      || call(stream, state)\n      || conditional(stream, state)\n      || each(stream, state)\n      || whileStatement(stream, state)\n      || tag(stream, state)\n      || filter(stream, state)\n      || code(stream, state)\n      || id(stream)\n      || className(stream)\n      || attrs(stream, state)\n      || attributesBlock(stream, state)\n      || indent(stream)\n      || text(stream, state)\n      || comment(stream, state)\n      || colon(stream)\n      || dot(stream, state)\n      || fail(stream);\n\n    return tok === true ? null : tok;\n  }\n  return {\n    startState: startState,\n    copyState: copyState,\n    token: nextToken\n  };\n}, 'javascript', 'css', 'htmlmixed');\n\nCodeMirror.defineMIME('text/x-pug', 'pug');\nCodeMirror.defineMIME('text/x-jade', 'pug');\n\n});\n","// CodeMirror, copyright (c) by Marijn Haverbeke and others\n// Distributed under an MIT license: https://codemirror.net/5/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\n  function wordRegexp(words) {\n    return new RegExp(\"^((\" + words.join(\")|(\") + \"))\\\\b\");\n  }\n\n  var wordOperators = wordRegexp([\"and\", \"or\", \"not\", \"is\"]);\n  var commonKeywords = [\"as\", \"assert\", \"break\", \"class\", \"continue\",\n                        \"def\", \"del\", \"elif\", \"else\", \"except\", \"finally\",\n                        \"for\", \"from\", \"global\", \"if\", \"import\",\n                        \"lambda\", \"pass\", \"raise\", \"return\",\n                        \"try\", \"while\", \"with\", \"yield\", \"in\", \"False\", \"True\"];\n  var commonBuiltins = [\"abs\", \"all\", \"any\", \"bin\", \"bool\", \"bytearray\", \"callable\", \"chr\",\n                        \"classmethod\", \"compile\", \"complex\", \"delattr\", \"dict\", \"dir\", \"divmod\",\n                        \"enumerate\", \"eval\", \"filter\", \"float\", \"format\", \"frozenset\",\n                        \"getattr\", \"globals\", \"hasattr\", \"hash\", \"help\", \"hex\", \"id\",\n                        \"input\", \"int\", \"isinstance\", \"issubclass\", \"iter\", \"len\",\n                        \"list\", \"locals\", \"map\", \"max\", \"memoryview\", \"min\", \"next\",\n                        \"object\", \"oct\", \"open\", \"ord\", \"pow\", \"property\", \"range\",\n                        \"repr\", \"reversed\", \"round\", \"set\", \"setattr\", \"slice\",\n                        \"sorted\", \"staticmethod\", \"str\", \"sum\", \"super\", \"tuple\",\n                        \"type\", \"vars\", \"zip\", \"__import__\", \"NotImplemented\",\n                        \"Ellipsis\", \"__debug__\"];\n  CodeMirror.registerHelper(\"hintWords\", \"python\", commonKeywords.concat(commonBuiltins).concat([\"exec\", \"print\"]));\n\n  function top(state) {\n    return state.scopes[state.scopes.length - 1];\n  }\n\n  CodeMirror.defineMode(\"python\", function(conf, parserConf) {\n    var ERRORCLASS = \"error\";\n\n    var delimiters = parserConf.delimiters || parserConf.singleDelimiters || /^[\\(\\)\\[\\]\\{\\}@,:`=;\\.\\\\]/;\n    //               (Backwards-compatibility with old, cumbersome config system)\n    var operators = [parserConf.singleOperators, parserConf.doubleOperators, parserConf.doubleDelimiters, parserConf.tripleDelimiters,\n                     parserConf.operators || /^([-+*/%\\/&|^]=?|[<>=]+|\\/\\/=?|\\*\\*=?|!=|[~!@]|\\.\\.\\.)/]\n    for (var i = 0; i < operators.length; i++) if (!operators[i]) operators.splice(i--, 1)\n\n    var hangingIndent = parserConf.hangingIndent || conf.indentUnit;\n\n    var myKeywords = commonKeywords, myBuiltins = commonBuiltins;\n    if (parserConf.extra_keywords != undefined)\n      myKeywords = myKeywords.concat(parserConf.extra_keywords);\n\n    if (parserConf.extra_builtins != undefined)\n      myBuiltins = myBuiltins.concat(parserConf.extra_builtins);\n\n    var py3 = !(parserConf.version && Number(parserConf.version) < 3)\n    if (py3) {\n      // since http://legacy.python.org/dev/peps/pep-0465/ @ is also an operator\n      var identifiers = parserConf.identifiers|| /^[_A-Za-z\\u00A1-\\uFFFF][_A-Za-z0-9\\u00A1-\\uFFFF]*/;\n      myKeywords = myKeywords.concat([\"nonlocal\", \"None\", \"aiter\", \"anext\", \"async\", \"await\", \"breakpoint\", \"match\", \"case\"]);\n      myBuiltins = myBuiltins.concat([\"ascii\", \"bytes\", \"exec\", \"print\"]);\n      var stringPrefixes = new RegExp(\"^(([rbuf]|(br)|(rb)|(fr)|(rf))?('{3}|\\\"{3}|['\\\"]))\", \"i\");\n    } else {\n      var identifiers = parserConf.identifiers|| /^[_A-Za-z][_A-Za-z0-9]*/;\n      myKeywords = myKeywords.concat([\"exec\", \"print\"]);\n      myBuiltins = myBuiltins.concat([\"apply\", \"basestring\", \"buffer\", \"cmp\", \"coerce\", \"execfile\",\n                                      \"file\", \"intern\", \"long\", \"raw_input\", \"reduce\", \"reload\",\n                                      \"unichr\", \"unicode\", \"xrange\", \"None\"]);\n      var stringPrefixes = new RegExp(\"^(([rubf]|(ur)|(br))?('{3}|\\\"{3}|['\\\"]))\", \"i\");\n    }\n    var keywords = wordRegexp(myKeywords);\n    var builtins = wordRegexp(myBuiltins);\n\n    // tokenizers\n    function tokenBase(stream, state) {\n      var sol = stream.sol() && state.lastToken != \"\\\\\"\n      if (sol) state.indent = stream.indentation()\n      // Handle scope changes\n      if (sol && top(state).type == \"py\") {\n        var scopeOffset = top(state).offset;\n        if (stream.eatSpace()) {\n          var lineOffset = stream.indentation();\n          if (lineOffset > scopeOffset)\n            pushPyScope(state);\n          else if (lineOffset < scopeOffset && dedent(stream, state) && stream.peek() != \"#\")\n            state.errorToken = true;\n          return null;\n        } else {\n          var style = tokenBaseInner(stream, state);\n          if (scopeOffset > 0 && dedent(stream, state))\n            style += \" \" + ERRORCLASS;\n          return style;\n        }\n      }\n      return tokenBaseInner(stream, state);\n    }\n\n    function tokenBaseInner(stream, state, inFormat) {\n      if (stream.eatSpace()) return null;\n\n      // Handle Comments\n      if (!inFormat && stream.match(/^#.*/)) return \"comment\";\n\n      // Handle Number Literals\n      if (stream.match(/^[0-9\\.]/, false)) {\n        var floatLiteral = false;\n        // Floats\n        if (stream.match(/^[\\d_]*\\.\\d+(e[\\+\\-]?\\d+)?/i)) { floatLiteral = true; }\n        if (stream.match(/^[\\d_]+\\.\\d*/)) { floatLiteral = true; }\n        if (stream.match(/^\\.\\d+/)) { floatLiteral = true; }\n        if (floatLiteral) {\n          // Float literals may be \"imaginary\"\n          stream.eat(/J/i);\n          return \"number\";\n        }\n        // Integers\n        var intLiteral = false;\n        // Hex\n        if (stream.match(/^0x[0-9a-f_]+/i)) intLiteral = true;\n        // Binary\n        if (stream.match(/^0b[01_]+/i)) intLiteral = true;\n        // Octal\n        if (stream.match(/^0o[0-7_]+/i)) intLiteral = true;\n        // Decimal\n        if (stream.match(/^[1-9][\\d_]*(e[\\+\\-]?[\\d_]+)?/)) {\n          // Decimal literals may be \"imaginary\"\n          stream.eat(/J/i);\n          // TODO - Can you have imaginary longs?\n          intLiteral = true;\n        }\n        // Zero by itself with no other piece of number.\n        if (stream.match(/^0(?![\\dx])/i)) intLiteral = true;\n        if (intLiteral) {\n          // Integer literals may be \"long\"\n          stream.eat(/L/i);\n          return \"number\";\n        }\n      }\n\n      // Handle Strings\n      if (stream.match(stringPrefixes)) {\n        var isFmtString = stream.current().toLowerCase().indexOf('f') !== -1;\n        if (!isFmtString) {\n          state.tokenize = tokenStringFactory(stream.current(), state.tokenize);\n          return state.tokenize(stream, state);\n        } else {\n          state.tokenize = formatStringFactory(stream.current(), state.tokenize);\n          return state.tokenize(stream, state);\n        }\n      }\n\n      for (var i = 0; i < operators.length; i++)\n        if (stream.match(operators[i])) return \"operator\"\n\n      if (stream.match(delimiters)) return \"punctuation\";\n\n      if (state.lastToken == \".\" && stream.match(identifiers))\n        return \"property\";\n\n      if (stream.match(keywords) || stream.match(wordOperators))\n        return \"keyword\";\n\n      if (stream.match(builtins))\n        return \"builtin\";\n\n      if (stream.match(/^(self|cls)\\b/))\n        return \"variable-2\";\n\n      if (stream.match(identifiers)) {\n        if (state.lastToken == \"def\" || state.lastToken == \"class\")\n          return \"def\";\n        return \"variable\";\n      }\n\n      // Handle non-detected items\n      stream.next();\n      return inFormat ? null :ERRORCLASS;\n    }\n\n    function formatStringFactory(delimiter, tokenOuter) {\n      while (\"rubf\".indexOf(delimiter.charAt(0).toLowerCase()) >= 0)\n        delimiter = delimiter.substr(1);\n\n      var singleline = delimiter.length == 1;\n      var OUTCLASS = \"string\";\n\n      function tokenNestedExpr(depth) {\n        return function(stream, state) {\n          var inner = tokenBaseInner(stream, state, true)\n          if (inner == \"punctuation\") {\n            if (stream.current() == \"{\") {\n              state.tokenize = tokenNestedExpr(depth + 1)\n            } else if (stream.current() == \"}\") {\n              if (depth > 1) state.tokenize = tokenNestedExpr(depth - 1)\n              else state.tokenize = tokenString\n            }\n          }\n          return inner\n        }\n      }\n\n      function tokenString(stream, state) {\n        while (!stream.eol()) {\n          stream.eatWhile(/[^'\"\\{\\}\\\\]/);\n          if (stream.eat(\"\\\\\")) {\n            stream.next();\n            if (singleline && stream.eol())\n              return OUTCLASS;\n          } else if (stream.match(delimiter)) {\n            state.tokenize = tokenOuter;\n            return OUTCLASS;\n          } else if (stream.match('{{')) {\n            // ignore {{ in f-str\n            return OUTCLASS;\n          } else if (stream.match('{', false)) {\n            // switch to nested mode\n            state.tokenize = tokenNestedExpr(0)\n            if (stream.current()) return OUTCLASS;\n            else return state.tokenize(stream, state)\n          } else if (stream.match('}}')) {\n            return OUTCLASS;\n          } else if (stream.match('}')) {\n            // single } in f-string is an error\n            return ERRORCLASS;\n          } else {\n            stream.eat(/['\"]/);\n          }\n        }\n        if (singleline) {\n          if (parserConf.singleLineStringErrors)\n            return ERRORCLASS;\n          else\n            state.tokenize = tokenOuter;\n        }\n        return OUTCLASS;\n      }\n      tokenString.isString = true;\n      return tokenString;\n    }\n\n    function tokenStringFactory(delimiter, tokenOuter) {\n      while (\"rubf\".indexOf(delimiter.charAt(0).toLowerCase()) >= 0)\n        delimiter = delimiter.substr(1);\n\n      var singleline = delimiter.length == 1;\n      var OUTCLASS = \"string\";\n\n      function tokenString(stream, state) {\n        while (!stream.eol()) {\n          stream.eatWhile(/[^'\"\\\\]/);\n          if (stream.eat(\"\\\\\")) {\n            stream.next();\n            if (singleline && stream.eol())\n              return OUTCLASS;\n          } else if (stream.match(delimiter)) {\n            state.tokenize = tokenOuter;\n            return OUTCLASS;\n          } else {\n            stream.eat(/['\"]/);\n          }\n        }\n        if (singleline) {\n          if (parserConf.singleLineStringErrors)\n            return ERRORCLASS;\n          else\n            state.tokenize = tokenOuter;\n        }\n        return OUTCLASS;\n      }\n      tokenString.isString = true;\n      return tokenString;\n    }\n\n    function pushPyScope(state) {\n      while (top(state).type != \"py\") state.scopes.pop()\n      state.scopes.push({offset: top(state).offset + conf.indentUnit,\n                         type: \"py\",\n                         align: null})\n    }\n\n    function pushBracketScope(stream, state, type) {\n      var align = stream.match(/^[\\s\\[\\{\\(]*(?:#|$)/, false) ? null : stream.column() + 1\n      state.scopes.push({offset: state.indent + hangingIndent,\n                         type: type,\n                         align: align})\n    }\n\n    function dedent(stream, state) {\n      var indented = stream.indentation();\n      while (state.scopes.length > 1 && top(state).offset > indented) {\n        if (top(state).type != \"py\") return true;\n        state.scopes.pop();\n      }\n      return top(state).offset != indented;\n    }\n\n    function tokenLexer(stream, state) {\n      if (stream.sol()) {\n        state.beginningOfLine = true;\n        state.dedent = false;\n      }\n\n      var style = state.tokenize(stream, state);\n      var current = stream.current();\n\n      // Handle decorators\n      if (state.beginningOfLine && current == \"@\")\n        return stream.match(identifiers, false) ? \"meta\" : py3 ? \"operator\" : ERRORCLASS;\n\n      if (/\\S/.test(current)) state.beginningOfLine = false;\n\n      if ((style == \"variable\" || style == \"builtin\")\n          && state.lastToken == \"meta\")\n        style = \"meta\";\n\n      // Handle scope changes.\n      if (current == \"pass\" || current == \"return\")\n        state.dedent = true;\n\n      if (current == \"lambda\") state.lambda = true;\n      if (current == \":\" && !state.lambda && top(state).type == \"py\" && stream.match(/^\\s*(?:#|$)/, false))\n        pushPyScope(state);\n\n      if (current.length == 1 && !/string|comment/.test(style)) {\n        var delimiter_index = \"[({\".indexOf(current);\n        if (delimiter_index != -1)\n          pushBracketScope(stream, state, \"])}\".slice(delimiter_index, delimiter_index+1));\n\n        delimiter_index = \"])}\".indexOf(current);\n        if (delimiter_index != -1) {\n          if (top(state).type == current) state.indent = state.scopes.pop().offset - hangingIndent\n          else return ERRORCLASS;\n        }\n      }\n      if (state.dedent && stream.eol() && top(state).type == \"py\" && state.scopes.length > 1)\n        state.scopes.pop();\n\n      return style;\n    }\n\n    var external = {\n      startState: function(basecolumn) {\n        return {\n          tokenize: tokenBase,\n          scopes: [{offset: basecolumn || 0, type: \"py\", align: null}],\n          indent: basecolumn || 0,\n          lastToken: null,\n          lambda: false,\n          dedent: 0\n        };\n      },\n\n      token: function(stream, state) {\n        var addErr = state.errorToken;\n        if (addErr) state.errorToken = false;\n        var style = tokenLexer(stream, state);\n\n        if (style && style != \"comment\")\n          state.lastToken = (style == \"keyword\" || style == \"punctuation\") ? stream.current() : style;\n        if (style == \"punctuation\") style = null;\n\n        if (stream.eol() && state.lambda)\n          state.lambda = false;\n        return addErr ? style + \" \" + ERRORCLASS : style;\n      },\n\n      indent: function(state, textAfter) {\n        if (state.tokenize != tokenBase)\n          return state.tokenize.isString ? CodeMirror.Pass : 0;\n\n        var scope = top(state)\n        var closing = scope.type == textAfter.charAt(0) ||\n            scope.type == \"py\" && !state.dedent && /^(else:|elif |except |finally:)/.test(textAfter)\n        if (scope.align != null)\n          return scope.align - (closing ? 1 : 0)\n        else\n          return scope.offset - (closing ? hangingIndent : 0)\n      },\n\n      electricInput: /^\\s*([\\}\\]\\)]|else:|elif |except |finally:)$/,\n      closeBrackets: {triples: \"'\\\"\"},\n      lineComment: \"#\",\n      fold: \"indent\"\n    };\n    return external;\n  });\n\n  CodeMirror.defineMIME(\"text/x-python\", \"python\");\n\n  var words = function(str) { return str.split(\" \"); };\n\n  CodeMirror.defineMIME(\"text/x-cython\", {\n    name: \"python\",\n    extra_keywords: words(\"by cdef cimport cpdef ctypedef enum except \"+\n                          \"extern gil include nogil property public \"+\n                          \"readonly struct union DEF IF ELIF ELSE\")\n  });\n\n});\n","// CodeMirror, copyright (c) by Marijn Haverbeke and others\n// Distributed under an MIT license: https://codemirror.net/5/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 wordObj(words) {\n  var o = {};\n  for (var i = 0, e = words.length; i < e; ++i) o[words[i]] = true;\n  return o;\n}\n\nvar keywordList = [\n  \"alias\", \"and\", \"BEGIN\", \"begin\", \"break\", \"case\", \"class\", \"def\", \"defined?\", \"do\", \"else\",\n  \"elsif\", \"END\", \"end\", \"ensure\", \"false\", \"for\", \"if\", \"in\", \"module\", \"next\", \"not\", \"or\",\n  \"redo\", \"rescue\", \"retry\", \"return\", \"self\", \"super\", \"then\", \"true\", \"undef\", \"unless\",\n  \"until\", \"when\", \"while\", \"yield\", \"nil\", \"raise\", \"throw\", \"catch\", \"fail\", \"loop\", \"callcc\",\n  \"caller\", \"lambda\", \"proc\", \"public\", \"protected\", \"private\", \"require\", \"load\",\n  \"require_relative\", \"extend\", \"autoload\", \"__END__\", \"__FILE__\", \"__LINE__\", \"__dir__\"\n], keywords = wordObj(keywordList);\n\nvar indentWords = wordObj([\"def\", \"class\", \"case\", \"for\", \"while\", \"until\", \"module\",\n                           \"catch\", \"loop\", \"proc\", \"begin\"]);\nvar dedentWords = wordObj([\"end\", \"until\"]);\nvar opening = {\"[\": \"]\", \"{\": \"}\", \"(\": \")\"};\nvar closing = {\"]\": \"[\", \"}\": \"{\", \")\": \"(\"};\n\nCodeMirror.defineMode(\"ruby\", function(config) {\n  var curPunc;\n\n  function chain(newtok, stream, state) {\n    state.tokenize.push(newtok);\n    return newtok(stream, state);\n  }\n\n  function tokenBase(stream, state) {\n    if (stream.sol() && stream.match(\"=begin\") && stream.eol()) {\n      state.tokenize.push(readBlockComment);\n      return \"comment\";\n    }\n    if (stream.eatSpace()) return null;\n    var ch = stream.next(), m;\n    if (ch == \"`\" || ch == \"'\" || ch == '\"') {\n      return chain(readQuoted(ch, \"string\", ch == '\"' || ch == \"`\"), stream, state);\n    } else if (ch == \"/\") {\n      if (regexpAhead(stream))\n        return chain(readQuoted(ch, \"string-2\", true), stream, state);\n      else\n        return \"operator\";\n    } else if (ch == \"%\") {\n      var style = \"string\", embed = true;\n      if (stream.eat(\"s\")) style = \"atom\";\n      else if (stream.eat(/[WQ]/)) style = \"string\";\n      else if (stream.eat(/[r]/)) style = \"string-2\";\n      else if (stream.eat(/[wxq]/)) { style = \"string\"; embed = false; }\n      var delim = stream.eat(/[^\\w\\s=]/);\n      if (!delim) return \"operator\";\n      if (opening.propertyIsEnumerable(delim)) delim = opening[delim];\n      return chain(readQuoted(delim, style, embed, true), stream, state);\n    } else if (ch == \"#\") {\n      stream.skipToEnd();\n      return \"comment\";\n    } else if (ch == \"<\" && (m = stream.match(/^<([-~])[\\`\\\"\\']?([a-zA-Z_?]\\w*)[\\`\\\"\\']?(?:;|$)/))) {\n      return chain(readHereDoc(m[2], m[1]), stream, state);\n    } else if (ch == \"0\") {\n      if (stream.eat(\"x\")) stream.eatWhile(/[\\da-fA-F]/);\n      else if (stream.eat(\"b\")) stream.eatWhile(/[01]/);\n      else stream.eatWhile(/[0-7]/);\n      return \"number\";\n    } else if (/\\d/.test(ch)) {\n      stream.match(/^[\\d_]*(?:\\.[\\d_]+)?(?:[eE][+\\-]?[\\d_]+)?/);\n      return \"number\";\n    } else if (ch == \"?\") {\n      while (stream.match(/^\\\\[CM]-/)) {}\n      if (stream.eat(\"\\\\\")) stream.eatWhile(/\\w/);\n      else stream.next();\n      return \"string\";\n    } else if (ch == \":\") {\n      if (stream.eat(\"'\")) return chain(readQuoted(\"'\", \"atom\", false), stream, state);\n      if (stream.eat('\"')) return chain(readQuoted('\"', \"atom\", true), stream, state);\n\n      // :> :>> :< :<< are valid symbols\n      if (stream.eat(/[\\<\\>]/)) {\n        stream.eat(/[\\<\\>]/);\n        return \"atom\";\n      }\n\n      // :+ :- :/ :* :| :& :! are valid symbols\n      if (stream.eat(/[\\+\\-\\*\\/\\&\\|\\:\\!]/)) {\n        return \"atom\";\n      }\n\n      // Symbols can't start by a digit\n      if (stream.eat(/[a-zA-Z$@_\\xa1-\\uffff]/)) {\n        stream.eatWhile(/[\\w$\\xa1-\\uffff]/);\n        // Only one ? ! = is allowed and only as the last character\n        stream.eat(/[\\?\\!\\=]/);\n        return \"atom\";\n      }\n      return \"operator\";\n    } else if (ch == \"@\" && stream.match(/^@?[a-zA-Z_\\xa1-\\uffff]/)) {\n      stream.eat(\"@\");\n      stream.eatWhile(/[\\w\\xa1-\\uffff]/);\n      return \"variable-2\";\n    } else if (ch == \"$\") {\n      if (stream.eat(/[a-zA-Z_]/)) {\n        stream.eatWhile(/[\\w]/);\n      } else if (stream.eat(/\\d/)) {\n        stream.eat(/\\d/);\n      } else {\n        stream.next(); // Must be a special global like $: or $!\n      }\n      return \"variable-3\";\n    } else if (/[a-zA-Z_\\xa1-\\uffff]/.test(ch)) {\n      stream.eatWhile(/[\\w\\xa1-\\uffff]/);\n      stream.eat(/[\\?\\!]/);\n      if (stream.eat(\":\")) return \"atom\";\n      return \"ident\";\n    } else if (ch == \"|\" && (state.varList || state.lastTok == \"{\" || state.lastTok == \"do\")) {\n      curPunc = \"|\";\n      return null;\n    } else if (/[\\(\\)\\[\\]{}\\\\;]/.test(ch)) {\n      curPunc = ch;\n      return null;\n    } else if (ch == \"-\" && stream.eat(\">\")) {\n      return \"arrow\";\n    } else if (/[=+\\-\\/*:\\.^%<>~|]/.test(ch)) {\n      var more = stream.eatWhile(/[=+\\-\\/*:\\.^%<>~|]/);\n      if (ch == \".\" && !more) curPunc = \".\";\n      return \"operator\";\n    } else {\n      return null;\n    }\n  }\n\n  function regexpAhead(stream) {\n    var start = stream.pos, depth = 0, next, found = false, escaped = false\n    while ((next = stream.next()) != null) {\n      if (!escaped) {\n        if (\"[{(\".indexOf(next) > -1) {\n          depth++\n        } else if (\"]})\".indexOf(next) > -1) {\n          depth--\n          if (depth < 0) break\n        } else if (next == \"/\" && depth == 0) {\n          found = true\n          break\n        }\n        escaped = next == \"\\\\\"\n      } else {\n        escaped = false\n      }\n    }\n    stream.backUp(stream.pos - start)\n    return found\n  }\n\n  function tokenBaseUntilBrace(depth) {\n    if (!depth) depth = 1;\n    return function(stream, state) {\n      if (stream.peek() == \"}\") {\n        if (depth == 1) {\n          state.tokenize.pop();\n          return state.tokenize[state.tokenize.length-1](stream, state);\n        } else {\n          state.tokenize[state.tokenize.length - 1] = tokenBaseUntilBrace(depth - 1);\n        }\n      } else if (stream.peek() == \"{\") {\n        state.tokenize[state.tokenize.length - 1] = tokenBaseUntilBrace(depth + 1);\n      }\n      return tokenBase(stream, state);\n    };\n  }\n  function tokenBaseOnce() {\n    var alreadyCalled = false;\n    return function(stream, state) {\n      if (alreadyCalled) {\n        state.tokenize.pop();\n        return state.tokenize[state.tokenize.length-1](stream, state);\n      }\n      alreadyCalled = true;\n      return tokenBase(stream, state);\n    };\n  }\n  function readQuoted(quote, style, embed, unescaped) {\n    return function(stream, state) {\n      var escaped = false, ch;\n\n      if (state.context.type === 'read-quoted-paused') {\n        state.context = state.context.prev;\n        stream.eat(\"}\");\n      }\n\n      while ((ch = stream.next()) != null) {\n        if (ch == quote && (unescaped || !escaped)) {\n          state.tokenize.pop();\n          break;\n        }\n        if (embed && ch == \"#\" && !escaped) {\n          if (stream.eat(\"{\")) {\n            if (quote == \"}\") {\n              state.context = {prev: state.context, type: 'read-quoted-paused'};\n            }\n            state.tokenize.push(tokenBaseUntilBrace());\n            break;\n          } else if (/[@\\$]/.test(stream.peek())) {\n            state.tokenize.push(tokenBaseOnce());\n            break;\n          }\n        }\n        escaped = !escaped && ch == \"\\\\\";\n      }\n      return style;\n    };\n  }\n  function readHereDoc(phrase, mayIndent) {\n    return function(stream, state) {\n      if (mayIndent) stream.eatSpace()\n      if (stream.match(phrase)) state.tokenize.pop();\n      else stream.skipToEnd();\n      return \"string\";\n    };\n  }\n  function readBlockComment(stream, state) {\n    if (stream.sol() && stream.match(\"=end\") && stream.eol())\n      state.tokenize.pop();\n    stream.skipToEnd();\n    return \"comment\";\n  }\n\n  return {\n    startState: function() {\n      return {tokenize: [tokenBase],\n              indented: 0,\n              context: {type: \"top\", indented: -config.indentUnit},\n              continuedLine: false,\n              lastTok: null,\n              varList: false};\n    },\n\n    token: function(stream, state) {\n      curPunc = null;\n      if (stream.sol()) state.indented = stream.indentation();\n      var style = state.tokenize[state.tokenize.length-1](stream, state), kwtype;\n      var thisTok = curPunc;\n      if (style == \"ident\") {\n        var word = stream.current();\n        style = state.lastTok == \".\" ? \"property\"\n          : keywords.propertyIsEnumerable(stream.current()) ? \"keyword\"\n          : /^[A-Z]/.test(word) ? \"tag\"\n          : (state.lastTok == \"def\" || state.lastTok == \"class\" || state.varList) ? \"def\"\n          : \"variable\";\n        if (style == \"keyword\") {\n          thisTok = word;\n          if (indentWords.propertyIsEnumerable(word)) kwtype = \"indent\";\n          else if (dedentWords.propertyIsEnumerable(word)) kwtype = \"dedent\";\n          else if ((word == \"if\" || word == \"unless\") && stream.column() == stream.indentation())\n            kwtype = \"indent\";\n          else if (word == \"do\" && state.context.indented < state.indented)\n            kwtype = \"indent\";\n        }\n      }\n      if (curPunc || (style && style != \"comment\")) state.lastTok = thisTok;\n      if (curPunc == \"|\") state.varList = !state.varList;\n\n      if (kwtype == \"indent\" || /[\\(\\[\\{]/.test(curPunc))\n        state.context = {prev: state.context, type: curPunc || style, indented: state.indented};\n      else if ((kwtype == \"dedent\" || /[\\)\\]\\}]/.test(curPunc)) && state.context.prev)\n        state.context = state.context.prev;\n\n      if (stream.eol())\n        state.continuedLine = (curPunc == \"\\\\\" || style == \"operator\");\n      return style;\n    },\n\n    indent: function(state, textAfter) {\n      if (state.tokenize[state.tokenize.length-1] != tokenBase) return CodeMirror.Pass;\n      var firstChar = textAfter && textAfter.charAt(0);\n      var ct = state.context;\n      var closed = ct.type == closing[firstChar] ||\n        ct.type == \"keyword\" && /^(?:end|until|else|elsif|when|rescue)\\b/.test(textAfter);\n      return ct.indented + (closed ? 0 : config.indentUnit) +\n        (state.continuedLine ? config.indentUnit : 0);\n    },\n\n    electricInput: /^\\s*(?:end|rescue|elsif|else|\\})$/,\n    lineComment: \"#\",\n    fold: \"indent\"\n  };\n});\n\nCodeMirror.defineMIME(\"text/x-ruby\", \"ruby\");\n\nCodeMirror.registerHelper(\"hintWords\", \"ruby\", keywordList);\n\n});\n","// CodeMirror, copyright (c) by Marijn Haverbeke and others\n// Distributed under an MIT license: https://codemirror.net/5/LICENSE\n\n(function(mod) {\n  if (typeof exports == \"object\" && typeof module == \"object\") // CommonJS\n    mod(require(\"../../lib/codemirror\"), require(\"../css/css\"));\n  else if (typeof define == \"function\" && define.amd) // AMD\n    define([\"../../lib/codemirror\", \"../css/css\"], mod);\n  else // Plain browser env\n    mod(CodeMirror);\n})(function(CodeMirror) {\n\"use strict\";\n\nCodeMirror.defineMode(\"sass\", function(config) {\n  var cssMode = CodeMirror.mimeModes[\"text/css\"];\n  var propertyKeywords = cssMode.propertyKeywords || {},\n      colorKeywords = cssMode.colorKeywords || {},\n      valueKeywords = cssMode.valueKeywords || {},\n      fontProperties = cssMode.fontProperties || {};\n\n  function tokenRegexp(words) {\n    return new RegExp(\"^\" + words.join(\"|\"));\n  }\n\n  var keywords = [\"true\", \"false\", \"null\", \"auto\"];\n  var keywordsRegexp = new RegExp(\"^\" + keywords.join(\"|\"));\n\n  var operators = [\"\\\\(\", \"\\\\)\", \"=\", \">\", \"<\", \"==\", \">=\", \"<=\", \"\\\\+\", \"-\",\n                   \"\\\\!=\", \"/\", \"\\\\*\", \"%\", \"and\", \"or\", \"not\", \";\",\"\\\\{\",\"\\\\}\",\":\"];\n  var opRegexp = tokenRegexp(operators);\n\n  var pseudoElementsRegexp = /^::?[a-zA-Z_][\\w\\-]*/;\n\n  var word;\n\n  function isEndLine(stream) {\n    return !stream.peek() || stream.match(/\\s+$/, false);\n  }\n\n  function urlTokens(stream, state) {\n    var ch = stream.peek();\n\n    if (ch === \")\") {\n      stream.next();\n      state.tokenizer = tokenBase;\n      return \"operator\";\n    } else if (ch === \"(\") {\n      stream.next();\n      stream.eatSpace();\n\n      return \"operator\";\n    } else if (ch === \"'\" || ch === '\"') {\n      state.tokenizer = buildStringTokenizer(stream.next());\n      return \"string\";\n    } else {\n      state.tokenizer = buildStringTokenizer(\")\", false);\n      return \"string\";\n    }\n  }\n  function comment(indentation, multiLine) {\n    return function(stream, state) {\n      if (stream.sol() && stream.indentation() <= indentation) {\n        state.tokenizer = tokenBase;\n        return tokenBase(stream, state);\n      }\n\n      if (multiLine && stream.skipTo(\"*/\")) {\n        stream.next();\n        stream.next();\n        state.tokenizer = tokenBase;\n      } else {\n        stream.skipToEnd();\n      }\n\n      return \"comment\";\n    };\n  }\n\n  function buildStringTokenizer(quote, greedy) {\n    if (greedy == null) { greedy = true; }\n\n    function stringTokenizer(stream, state) {\n      var nextChar = stream.next();\n      var peekChar = stream.peek();\n      var previousChar = stream.string.charAt(stream.pos-2);\n\n      var endingString = ((nextChar !== \"\\\\\" && peekChar === quote) || (nextChar === quote && previousChar !== \"\\\\\"));\n\n      if (endingString) {\n        if (nextChar !== quote && greedy) { stream.next(); }\n        if (isEndLine(stream)) {\n          state.cursorHalf = 0;\n        }\n        state.tokenizer = tokenBase;\n        return \"string\";\n      } else if (nextChar === \"#\" && peekChar === \"{\") {\n        state.tokenizer = buildInterpolationTokenizer(stringTokenizer);\n        stream.next();\n        return \"operator\";\n      } else {\n        return \"string\";\n      }\n    }\n\n    return stringTokenizer;\n  }\n\n  function buildInterpolationTokenizer(currentTokenizer) {\n    return function(stream, state) {\n      if (stream.peek() === \"}\") {\n        stream.next();\n        state.tokenizer = currentTokenizer;\n        return \"operator\";\n      } else {\n        return tokenBase(stream, state);\n      }\n    };\n  }\n\n  function indent(state) {\n    if (state.indentCount == 0) {\n      state.indentCount++;\n      var lastScopeOffset = state.scopes[0].offset;\n      var currentOffset = lastScopeOffset + config.indentUnit;\n      state.scopes.unshift({ offset:currentOffset });\n    }\n  }\n\n  function dedent(state) {\n    if (state.scopes.length == 1) return;\n\n    state.scopes.shift();\n  }\n\n  function tokenBase(stream, state) {\n    var ch = stream.peek();\n\n    // Comment\n    if (stream.match(\"/*\")) {\n      state.tokenizer = comment(stream.indentation(), true);\n      return state.tokenizer(stream, state);\n    }\n    if (stream.match(\"//\")) {\n      state.tokenizer = comment(stream.indentation(), false);\n      return state.tokenizer(stream, state);\n    }\n\n    // Interpolation\n    if (stream.match(\"#{\")) {\n      state.tokenizer = buildInterpolationTokenizer(tokenBase);\n      return \"operator\";\n    }\n\n    // Strings\n    if (ch === '\"' || ch === \"'\") {\n      stream.next();\n      state.tokenizer = buildStringTokenizer(ch);\n      return \"string\";\n    }\n\n    if(!state.cursorHalf){// state.cursorHalf === 0\n    // first half i.e. before : for key-value pairs\n    // including selectors\n\n      if (ch === \"-\") {\n        if (stream.match(/^-\\w+-/)) {\n          return \"meta\";\n        }\n      }\n\n      if (ch === \".\") {\n        stream.next();\n        if (stream.match(/^[\\w-]+/)) {\n          indent(state);\n          return \"qualifier\";\n        } else if (stream.peek() === \"#\") {\n          indent(state);\n          return \"tag\";\n        }\n      }\n\n      if (ch === \"#\") {\n        stream.next();\n        // ID selectors\n        if (stream.match(/^[\\w-]+/)) {\n          indent(state);\n          return \"builtin\";\n        }\n        if (stream.peek() === \"#\") {\n          indent(state);\n          return \"tag\";\n        }\n      }\n\n      // Variables\n      if (ch === \"$\") {\n        stream.next();\n        stream.eatWhile(/[\\w-]/);\n        return \"variable-2\";\n      }\n\n      // Numbers\n      if (stream.match(/^-?[0-9\\.]+/))\n        return \"number\";\n\n      // Units\n      if (stream.match(/^(px|em|in)\\b/))\n        return \"unit\";\n\n      if (stream.match(keywordsRegexp))\n        return \"keyword\";\n\n      if (stream.match(/^url/) && stream.peek() === \"(\") {\n        state.tokenizer = urlTokens;\n        return \"atom\";\n      }\n\n      if (ch === \"=\") {\n        // Match shortcut mixin definition\n        if (stream.match(/^=[\\w-]+/)) {\n          indent(state);\n          return \"meta\";\n        }\n      }\n\n      if (ch === \"+\") {\n        // Match shortcut mixin definition\n        if (stream.match(/^\\+[\\w-]+/)){\n          return \"variable-3\";\n        }\n      }\n\n      if(ch === \"@\"){\n        if(stream.match('@extend')){\n          if(!stream.match(/\\s*[\\w]/))\n            dedent(state);\n        }\n      }\n\n\n      // Indent Directives\n      if (stream.match(/^@(else if|if|media|else|for|each|while|mixin|function)/)) {\n        indent(state);\n        return \"def\";\n      }\n\n      // Other Directives\n      if (ch === \"@\") {\n        stream.next();\n        stream.eatWhile(/[\\w-]/);\n        return \"def\";\n      }\n\n      if (stream.eatWhile(/[\\w-]/)){\n        if(stream.match(/ *: *[\\w-\\+\\$#!\\(\"']/,false)){\n          word = stream.current().toLowerCase();\n          var prop = state.prevProp + \"-\" + word;\n          if (propertyKeywords.hasOwnProperty(prop)) {\n            return \"property\";\n          } else if (propertyKeywords.hasOwnProperty(word)) {\n            state.prevProp = word;\n            return \"property\";\n          } else if (fontProperties.hasOwnProperty(word)) {\n            return \"property\";\n          }\n          return \"tag\";\n        }\n        else if(stream.match(/ *:/,false)){\n          indent(state);\n          state.cursorHalf = 1;\n          state.prevProp = stream.current().toLowerCase();\n          return \"property\";\n        }\n        else if(stream.match(/ *,/,false)){\n          return \"tag\";\n        }\n        else{\n          indent(state);\n          return \"tag\";\n        }\n      }\n\n      if(ch === \":\"){\n        if (stream.match(pseudoElementsRegexp)){ // could be a pseudo-element\n          return \"variable-3\";\n        }\n        stream.next();\n        state.cursorHalf=1;\n        return \"operator\";\n      }\n\n    } // cursorHalf===0 ends here\n    else{\n\n      if (ch === \"#\") {\n        stream.next();\n        // Hex numbers\n        if (stream.match(/[0-9a-fA-F]{6}|[0-9a-fA-F]{3}/)){\n          if (isEndLine(stream)) {\n            state.cursorHalf = 0;\n          }\n          return \"number\";\n        }\n      }\n\n      // Numbers\n      if (stream.match(/^-?[0-9\\.]+/)){\n        if (isEndLine(stream)) {\n          state.cursorHalf = 0;\n        }\n        return \"number\";\n      }\n\n      // Units\n      if (stream.match(/^(px|em|in)\\b/)){\n        if (isEndLine(stream)) {\n          state.cursorHalf = 0;\n        }\n        return \"unit\";\n      }\n\n      if (stream.match(keywordsRegexp)){\n        if (isEndLine(stream)) {\n          state.cursorHalf = 0;\n        }\n        return \"keyword\";\n      }\n\n      if (stream.match(/^url/) && stream.peek() === \"(\") {\n        state.tokenizer = urlTokens;\n        if (isEndLine(stream)) {\n          state.cursorHalf = 0;\n        }\n        return \"atom\";\n      }\n\n      // Variables\n      if (ch === \"$\") {\n        stream.next();\n        stream.eatWhile(/[\\w-]/);\n        if (isEndLine(stream)) {\n          state.cursorHalf = 0;\n        }\n        return \"variable-2\";\n      }\n\n      // bang character for !important, !default, etc.\n      if (ch === \"!\") {\n        stream.next();\n        state.cursorHalf = 0;\n        return stream.match(/^[\\w]+/) ? \"keyword\": \"operator\";\n      }\n\n      if (stream.match(opRegexp)){\n        if (isEndLine(stream)) {\n          state.cursorHalf = 0;\n        }\n        return \"operator\";\n      }\n\n      // attributes\n      if (stream.eatWhile(/[\\w-]/)) {\n        if (isEndLine(stream)) {\n          state.cursorHalf = 0;\n        }\n        word = stream.current().toLowerCase();\n        if (valueKeywords.hasOwnProperty(word)) {\n          return \"atom\";\n        } else if (colorKeywords.hasOwnProperty(word)) {\n          return \"keyword\";\n        } else if (propertyKeywords.hasOwnProperty(word)) {\n          state.prevProp = stream.current().toLowerCase();\n          return \"property\";\n        } else {\n          return \"tag\";\n        }\n      }\n\n      //stream.eatSpace();\n      if (isEndLine(stream)) {\n        state.cursorHalf = 0;\n        return null;\n      }\n\n    } // else ends here\n\n    if (stream.match(opRegexp))\n      return \"operator\";\n\n    // If we haven't returned by now, we move 1 character\n    // and return an error\n    stream.next();\n    return null;\n  }\n\n  function tokenLexer(stream, state) {\n    if (stream.sol()) state.indentCount = 0;\n    var style = state.tokenizer(stream, state);\n    var current = stream.current();\n\n    if (current === \"@return\" || current === \"}\"){\n      dedent(state);\n    }\n\n    if (style !== null) {\n      var startOfToken = stream.pos - current.length;\n\n      var withCurrentIndent = startOfToken + (config.indentUnit * state.indentCount);\n\n      var newScopes = [];\n\n      for (var i = 0; i < state.scopes.length; i++) {\n        var scope = state.scopes[i];\n\n        if (scope.offset <= withCurrentIndent)\n          newScopes.push(scope);\n      }\n\n      state.scopes = newScopes;\n    }\n\n\n    return style;\n  }\n\n  return {\n    startState: function() {\n      return {\n        tokenizer: tokenBase,\n        scopes: [{offset: 0, type: \"sass\"}],\n        indentCount: 0,\n        cursorHalf: 0,  // cursor half tells us if cursor lies after (1)\n                        // or before (0) colon (well... more or less)\n        definedVars: [],\n        definedMixins: []\n      };\n    },\n    token: function(stream, state) {\n      var style = tokenLexer(stream, state);\n\n      state.lastToken = { style: style, content: stream.current() };\n\n      return style;\n    },\n\n    indent: function(state) {\n      return state.scopes[0].offset;\n    },\n\n    blockCommentStart: \"/*\",\n    blockCommentEnd: \"*/\",\n    lineComment: \"//\",\n    fold: \"indent\"\n  };\n}, \"css\");\n\nCodeMirror.defineMIME(\"text/x-sass\", \"sass\");\n\n});\n","// CodeMirror, copyright (c) by Marijn Haverbeke and others\n// Distributed under an MIT license: https://codemirror.net/5/LICENSE\n\n/*\n * Author: Constantin Jucovschi (c.jucovschi@jacobs-university.de)\n * Licence: MIT\n */\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\n  CodeMirror.defineMode(\"stex\", function(_config, parserConfig) {\n    \"use strict\";\n\n    function pushCommand(state, command) {\n      state.cmdState.push(command);\n    }\n\n    function peekCommand(state) {\n      if (state.cmdState.length > 0) {\n        return state.cmdState[state.cmdState.length - 1];\n      } else {\n        return null;\n      }\n    }\n\n    function popCommand(state) {\n      var plug = state.cmdState.pop();\n      if (plug) {\n        plug.closeBracket();\n      }\n    }\n\n    // returns the non-default plugin closest to the end of the list\n    function getMostPowerful(state) {\n      var context = state.cmdState;\n      for (var i = context.length - 1; i >= 0; i--) {\n        var plug = context[i];\n        if (plug.name == \"DEFAULT\") {\n          continue;\n        }\n        return plug;\n      }\n      return { styleIdentifier: function() { return null; } };\n    }\n\n    function addPluginPattern(pluginName, cmdStyle, styles) {\n      return function () {\n        this.name = pluginName;\n        this.bracketNo = 0;\n        this.style = cmdStyle;\n        this.styles = styles;\n        this.argument = null;   // \\begin and \\end have arguments that follow. These are stored in the plugin\n\n        this.styleIdentifier = function() {\n          return this.styles[this.bracketNo - 1] || null;\n        };\n        this.openBracket = function() {\n          this.bracketNo++;\n          return \"bracket\";\n        };\n        this.closeBracket = function() {};\n      };\n    }\n\n    var plugins = {};\n\n    plugins[\"importmodule\"] = addPluginPattern(\"importmodule\", \"tag\", [\"string\", \"builtin\"]);\n    plugins[\"documentclass\"] = addPluginPattern(\"documentclass\", \"tag\", [\"\", \"atom\"]);\n    plugins[\"usepackage\"] = addPluginPattern(\"usepackage\", \"tag\", [\"atom\"]);\n    plugins[\"begin\"] = addPluginPattern(\"begin\", \"tag\", [\"atom\"]);\n    plugins[\"end\"] = addPluginPattern(\"end\", \"tag\", [\"atom\"]);\n\n    plugins[\"label\"    ] = addPluginPattern(\"label\"    , \"tag\", [\"atom\"]);\n    plugins[\"ref\"      ] = addPluginPattern(\"ref\"      , \"tag\", [\"atom\"]);\n    plugins[\"eqref\"    ] = addPluginPattern(\"eqref\"    , \"tag\", [\"atom\"]);\n    plugins[\"cite\"     ] = addPluginPattern(\"cite\"     , \"tag\", [\"atom\"]);\n    plugins[\"bibitem\"  ] = addPluginPattern(\"bibitem\"  , \"tag\", [\"atom\"]);\n    plugins[\"Bibitem\"  ] = addPluginPattern(\"Bibitem\"  , \"tag\", [\"atom\"]);\n    plugins[\"RBibitem\" ] = addPluginPattern(\"RBibitem\" , \"tag\", [\"atom\"]);\n\n    plugins[\"DEFAULT\"] = function () {\n      this.name = \"DEFAULT\";\n      this.style = \"tag\";\n\n      this.styleIdentifier = this.openBracket = this.closeBracket = function() {};\n    };\n\n    function setState(state, f) {\n      state.f = f;\n    }\n\n    // called when in a normal (no environment) context\n    function normal(source, state) {\n      var plug;\n      // Do we look like '\\command' ?  If so, attempt to apply the plugin 'command'\n      if (source.match(/^\\\\[a-zA-Z@]+/)) {\n        var cmdName = source.current().slice(1);\n        plug = plugins.hasOwnProperty(cmdName) ? plugins[cmdName] : plugins[\"DEFAULT\"];\n        plug = new plug();\n        pushCommand(state, plug);\n        setState(state, beginParams);\n        return plug.style;\n      }\n\n      // escape characters\n      if (source.match(/^\\\\[$&%#{}_]/)) {\n        return \"tag\";\n      }\n\n      // white space control characters\n      if (source.match(/^\\\\[,;!\\/\\\\]/)) {\n        return \"tag\";\n      }\n\n      // find if we're starting various math modes\n      if (source.match(\"\\\\[\")) {\n        setState(state, function(source, state){ return inMathMode(source, state, \"\\\\]\"); });\n        return \"keyword\";\n      }\n      if (source.match(\"\\\\(\")) {\n        setState(state, function(source, state){ return inMathMode(source, state, \"\\\\)\"); });\n        return \"keyword\";\n      }\n      if (source.match(\"$$\")) {\n        setState(state, function(source, state){ return inMathMode(source, state, \"$$\"); });\n        return \"keyword\";\n      }\n      if (source.match(\"$\")) {\n        setState(state, function(source, state){ return inMathMode(source, state, \"$\"); });\n        return \"keyword\";\n      }\n\n      var ch = source.next();\n      if (ch == \"%\") {\n        source.skipToEnd();\n        return \"comment\";\n      } else if (ch == '}' || ch == ']') {\n        plug = peekCommand(state);\n        if (plug) {\n          plug.closeBracket(ch);\n          setState(state, beginParams);\n        } else {\n          return \"error\";\n        }\n        return \"bracket\";\n      } else if (ch == '{' || ch == '[') {\n        plug = plugins[\"DEFAULT\"];\n        plug = new plug();\n        pushCommand(state, plug);\n        return \"bracket\";\n      } else if (/\\d/.test(ch)) {\n        source.eatWhile(/[\\w.%]/);\n        return \"atom\";\n      } else {\n        source.eatWhile(/[\\w\\-_]/);\n        plug = getMostPowerful(state);\n        if (plug.name == 'begin') {\n          plug.argument = source.current();\n        }\n        return plug.styleIdentifier();\n      }\n    }\n\n    function inMathMode(source, state, endModeSeq) {\n      if (source.eatSpace()) {\n        return null;\n      }\n      if (endModeSeq && source.match(endModeSeq)) {\n        setState(state, normal);\n        return \"keyword\";\n      }\n      if (source.match(/^\\\\[a-zA-Z@]+/)) {\n        return \"tag\";\n      }\n      if (source.match(/^[a-zA-Z]+/)) {\n        return \"variable-2\";\n      }\n      // escape characters\n      if (source.match(/^\\\\[$&%#{}_]/)) {\n        return \"tag\";\n      }\n      // white space control characters\n      if (source.match(/^\\\\[,;!\\/]/)) {\n        return \"tag\";\n      }\n      // special math-mode characters\n      if (source.match(/^[\\^_&]/)) {\n        return \"tag\";\n      }\n      // non-special characters\n      if (source.match(/^[+\\-<>|=,\\/@!*:;'\"`~#?]/)) {\n        return null;\n      }\n      if (source.match(/^(\\d+\\.\\d*|\\d*\\.\\d+|\\d+)/)) {\n        return \"number\";\n      }\n      var ch = source.next();\n      if (ch == \"{\" || ch == \"}\" || ch == \"[\" || ch == \"]\" || ch == \"(\" || ch == \")\") {\n        return \"bracket\";\n      }\n\n      if (ch == \"%\") {\n        source.skipToEnd();\n        return \"comment\";\n      }\n      return \"error\";\n    }\n\n    function beginParams(source, state) {\n      var ch = source.peek(), lastPlug;\n      if (ch == '{' || ch == '[') {\n        lastPlug = peekCommand(state);\n        lastPlug.openBracket(ch);\n        source.eat(ch);\n        setState(state, normal);\n        return \"bracket\";\n      }\n      if (/[ \\t\\r]/.test(ch)) {\n        source.eat(ch);\n        return null;\n      }\n      setState(state, normal);\n      popCommand(state);\n\n      return normal(source, state);\n    }\n\n    return {\n      startState: function() {\n        var f = parserConfig.inMathMode ? function(source, state){ return inMathMode(source, state); } : normal;\n        return {\n          cmdState: [],\n          f: f\n        };\n      },\n      copyState: function(s) {\n        return {\n          cmdState: s.cmdState.slice(),\n          f: s.f\n        };\n      },\n      token: function(stream, state) {\n        return state.f(stream, state);\n      },\n      blankLine: function(state) {\n        state.f = normal;\n        state.cmdState.length = 0;\n      },\n      lineComment: \"%\"\n    };\n  });\n\n  CodeMirror.defineMIME(\"text/x-stex\", \"stex\");\n  CodeMirror.defineMIME(\"text/x-latex\", \"stex\");\n\n});\n","// CodeMirror, copyright (c) by Marijn Haverbeke and others\n// Distributed under an MIT license: https://codemirror.net/5/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\nCodeMirror.defineMode(\"yaml\", function() {\n\n  var cons = ['true', 'false', 'on', 'off', 'yes', 'no'];\n  var keywordRegex = new RegExp(\"\\\\b((\"+cons.join(\")|(\")+\"))$\", 'i');\n\n  return {\n    token: function(stream, state) {\n      var ch = stream.peek();\n      var esc = state.escaped;\n      state.escaped = false;\n      /* comments */\n      if (ch == \"#\" && (stream.pos == 0 || /\\s/.test(stream.string.charAt(stream.pos - 1)))) {\n        stream.skipToEnd();\n        return \"comment\";\n      }\n\n      if (stream.match(/^('([^']|\\\\.)*'?|\"([^\"]|\\\\.)*\"?)/))\n        return \"string\";\n\n      if (state.literal && stream.indentation() > state.keyCol) {\n        stream.skipToEnd(); return \"string\";\n      } else if (state.literal) { state.literal = false; }\n      if (stream.sol()) {\n        state.keyCol = 0;\n        state.pair = false;\n        state.pairStart = false;\n        /* document start */\n        if(stream.match('---')) { return \"def\"; }\n        /* document end */\n        if (stream.match('...')) { return \"def\"; }\n        /* array list item */\n        if (stream.match(/\\s*-\\s+/)) { return 'meta'; }\n      }\n      /* inline pairs/lists */\n      if (stream.match(/^(\\{|\\}|\\[|\\])/)) {\n        if (ch == '{')\n          state.inlinePairs++;\n        else if (ch == '}')\n          state.inlinePairs--;\n        else if (ch == '[')\n          state.inlineList++;\n        else\n          state.inlineList--;\n        return 'meta';\n      }\n\n      /* list separator */\n      if (state.inlineList > 0 && !esc && ch == ',') {\n        stream.next();\n        return 'meta';\n      }\n      /* pairs separator */\n      if (state.inlinePairs > 0 && !esc && ch == ',') {\n        state.keyCol = 0;\n        state.pair = false;\n        state.pairStart = false;\n        stream.next();\n        return 'meta';\n      }\n\n      /* start of value of a pair */\n      if (state.pairStart) {\n        /* block literals */\n        if (stream.match(/^\\s*(\\||\\>)\\s*/)) { state.literal = true; return 'meta'; };\n        /* references */\n        if (stream.match(/^\\s*(\\&|\\*)[a-z0-9\\._-]+\\b/i)) { return 'variable-2'; }\n        /* numbers */\n        if (state.inlinePairs == 0 && stream.match(/^\\s*-?[0-9\\.\\,]+\\s?$/)) { return 'number'; }\n        if (state.inlinePairs > 0 && stream.match(/^\\s*-?[0-9\\.\\,]+\\s?(?=(,|}))/)) { return 'number'; }\n        /* keywords */\n        if (stream.match(keywordRegex)) { return 'keyword'; }\n      }\n\n      /* pairs (associative arrays) -> key */\n      if (!state.pair && stream.match(/^\\s*(?:[,\\[\\]{}&*!|>'\"%@`][^\\s'\":]|[^\\s,\\[\\]{}#&*!|>'\"%@`])[^#:]*(?=:($|\\s))/)) {\n        state.pair = true;\n        state.keyCol = stream.indentation();\n        return \"atom\";\n      }\n      if (state.pair && stream.match(/^:\\s*/)) { state.pairStart = true; return 'meta'; }\n\n      /* nothing found, continue */\n      state.pairStart = false;\n      state.escaped = (ch == '\\\\');\n      stream.next();\n      return null;\n    },\n    startState: function() {\n      return {\n        pair: false,\n        pairStart: false,\n        keyCol: 0,\n        inlinePairs: 0,\n        inlineList: 0,\n        literal: false,\n        escaped: false\n      };\n    },\n    lineComment: \"#\",\n    fold: \"indent\"\n  };\n});\n\nCodeMirror.defineMIME(\"text/x-yaml\", \"yaml\");\nCodeMirror.defineMIME(\"text/yaml\", \"yaml\");\n\n});\n"],"names":["FilterListController","Controller","targets","values","clearButtonId","String","connect","document","getElementById","this","clearButtonIdValue","addEventListener","resetFilterViaClearButton","disconnect","removeEventListener","filterLists","query","filterTarget","value","toLowerCase","showNoResultsText","searchItemTargets","forEach","item","text","querySelector","textContent","includes","setVisibility","hasNoResultsTextTarget","noResultsTextTarget","element","visible","classList","toggle","ProjectStorageFormController","folderMode","placeholderFolderName","notLoggedInValidation","lastProjectFolders","Object","combineLatest","fetchStorageAuthorizationState","fetchProjectFolder","subscribe","isConnected","projectFolder","displayFolderSelectionOrLoginButton","toggleFolderDisplay","folderModeValue","setProjectFolderModeQueryParam","selectProjectFolder","_evt","locals","projectFolderHref","createFolderHref","storage","_links","self","href","pluginContext","context","runInZone","services","opModalService","show","LocationPickerModalComponent","OutletTarget","pipe","switchMap","modal","closingEvent","filter","submitted","hasProjectFolderIdValidationTarget","projectFolderIdValidationTarget","style","display","selectedFolderTextTarget","innerText","location","name","projectFolderIdInputTarget","id","updateForm","evt","mode","target","manual","automatic","lastProjectFoldersValue","placeholderFolderNameValue","from","window","OpenProject","getPluginContext","PortalOutletTarget","Default","JSON","parse","storageTarget","dataset","projectFolderId","length","fetch","then","data","json","map","authorizationState","storageConnected","of","file","_type","selectProjectFolderButtonTarget","remove","loginButtonTarget","add","notLoggedInValidationValue","url","URL","searchParams","set","history","replaceState","state","hasProjectFolderSectionTarget","projectFolderSectionTarget","CodeMirror","multiplexingMode","outer","others","Array","prototype","slice","call","arguments","indexOf","string","pattern","returnEnd","found","m","exec","index","startState","innerActive","inner","startingInner","copyState","token","stream","curInner","oldContent","close","sol","pos","parseDelimiters","match","delimStyle","innerToken","start","innerStyle","cutOff","Infinity","i","other","open","outerIndent","indent","possibleOuterIndent","Pass","outerToken","textAfter","line","blankLine","electricChars","innerMode","mod","require","overlayMode","base","overlay","combine","basePos","baseCur","overlayPos","overlayCur","streamSeen","Math","min","combineTokens","baseToken","overlayToken","ensureState","states","hasOwnProperty","Error","toRegex","val","caret","flags","RegExp","ignoreCase","unicode","source","asToken","apply","replace","result","push","Rule","next","regex","tokenFunction","config","pending","pend","shift","local","end","tok","endToken","localState","endScan","current","curState","rule","matches","stack","pop","enterLocalMode","indentation","indentUnit","dedent","j","backUp","join","cmp","a","b","props","prop","spec","pers","persistent","p","persistentStates","getMode","lState","forceEnd","arr","indentFunction","meta","dontIndentStates","rules","scan","dedentIfLineStart","defineSimpleMode","defineMode","simpleMode","states_","hasIndentation","list","orig","s","conf","parserConf","ERRORCLASS","wordRegexp","words","operators","delimiters","identifiers","atProp","wordOperators","indentKeywords","commonKeywords","keywords","concat","stringPrefixes","regexPrefixes","constants","tokenBase","scope","align","scopeOffset","offset","eatSpace","lineOffset","type","ch","peek","skipToEnd","tokenize","longComment","floatLiteral","intLiteral","tokenFactory","delimiter","singleline","outclass","eol","eatWhile","eat","singleLineStringErrors","alignOffset","prev","column","_indent","matched","tokenLexer","delimiter_index","basecolumn","fillAlign","closer","charAt","closes","lineComment","fold","defineMIME","handlebars_raw","handlebars","dash_comment","comment","blockCommentStart","blockCommentEnd","parserConfig","_config","modeConfig","switchState","setState","f","smallRE","largeRE","digitRE","hexitRE","octitRE","idRE","symbolRE","specialRE","whiteCharRE","normal","test","t","ncomment","stringLiteral","nest","currNest","stringGap","wellKnownWords","wkw","setType","override","overrideKeywords","word","w","KEYWORD","DOCTYPE","ID","CLASS","ATTRS_NEST","jsMode","State","javaScriptLine","javaScriptLineExcludesColon","javaScriptArguments","javaScriptArgumentsDepth","isInterpolating","interpolationNesting","jsState","restOfLine","isIncludeFiltered","isEach","lastTag","scriptType","isAttrs","attrsNest","inAttributeName","attributeIsType","attrValue","indentOf","indentToken","innerState","innerModeForLine","javaScript","yieldStatement","doctype","interpolation","interpolationContinued","caseStatement","when","defaultStatement","extendsStatement","append","prepend","block","include","includeFiltered","includeFilteredContinued","mixin","mixinCallAfter","callArguments","conditional","each","eachContinued","whileStatement","tag","captures","innerModes","substring","setInnerMode","code","className","attrs","attrsContinued","trim","toString","Function","ex","attributesBlock","colon","dot","fail","mimeModes","force","hideFirstChars","copy","nextToken","res","commonBuiltins","top","scopes","registerHelper","singleDelimiters","singleOperators","doubleOperators","doubleDelimiters","tripleDelimiters","splice","hangingIndent","myKeywords","myBuiltins","undefined","extra_keywords","extra_builtins","py3","version","Number","builtins","lastToken","pushPyScope","errorToken","tokenBaseInner","inFormat","formatStringFactory","tokenStringFactory","tokenOuter","substr","OUTCLASS","tokenNestedExpr","depth","tokenString","isString","pushBracketScope","indented","beginningOfLine","lambda","addErr","closing","electricInput","closeBrackets","triples","str","split","wordObj","o","e","keywordList","indentWords","dedentWords","opening","curPunc","chain","newtok","readBlockComment","readQuoted","regexpAhead","embed","delim","propertyIsEnumerable","readHereDoc","varList","lastTok","more","escaped","tokenBaseUntilBrace","tokenBaseOnce","alreadyCalled","quote","unescaped","phrase","mayIndent","continuedLine","kwtype","thisTok","firstChar","ct","closed","cssMode","propertyKeywords","colorKeywords","valueKeywords","fontProperties","tokenRegexp","keywordsRegexp","opRegexp","pseudoElementsRegexp","isEndLine","urlTokens","tokenizer","buildStringTokenizer","multiLine","skipTo","greedy","stringTokenizer","nextChar","peekChar","previousChar","cursorHalf","buildInterpolationTokenizer","currentTokenizer","indentCount","currentOffset","unshift","prevProp","withCurrentIndent","newScopes","definedVars","definedMixins","content","pushCommand","command","cmdState","peekCommand","popCommand","plug","closeBracket","getMostPowerful","styleIdentifier","addPluginPattern","pluginName","cmdStyle","styles","bracketNo","argument","openBracket","plugins","cmdName","beginParams","inMathMode","endModeSeq","keywordRegex","esc","literal","keyCol","pair","pairStart","inlinePairs","inlineList"],"sourceRoot":"webpack:///","x_google_ignoreList":[2,3,4,5,6,7,8,9,10,11,12,13]}