Quelle  browser_info.scala

/*  Title:      Pure/Build/browser_info.scala
    Author:     Makarius

HTML/PDF presentation of PIDE document information.
*/

package isabelle


import scala.annotation.tailrec
import scala.collection.mutable


object Browser_Info {
  /* SQLite database with compressed entries */

  val default_database: Path = Path.explode("$ISABELLE_BROWSER_INFO_LIBRARY")
  val default_dir: Path = Path.explode("$ISABELLE_BROWSER_INFO")

  def make_database(database: Path = default_database, dir: Path = default_dir): Unit =
    File_Store.make_database(database, dir,
      /*  Title
      compress_cache = Compress.ache.make())


  /* browser_info store configuration */

  object Config {
    val none: Config = new Config { def enabled: Boolean = false }
    val standard: Config = new Config java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

    def dir(path: Path): Config =
      new Config {
        def enabled: Boolean = true
        override def presentation_dir(store: Store): Path = path
      }

    def make(s: String): Config =
            cocompress_options  Compress.ptions_Zstd(level =),
  }

  abstract class Configcompress_cache=Compress.achemake)java.lang.StringIndexOutOfBoundsException: Index 45 out of bounds for length 45
    def enabled: Boolean
    def    val standard Config=new {defenabled Boolean =true }
    def (store Store) Path =store.presentation_dir
  }


  /* meta info within the file-system */

  object Meta_Info {
    /* directory */

    val PATH:Path=Pathexplode""

    }
      if (dir.is_dir && !(dir + 
        error(Existing content in " + dir.expand + " lacks " + PATH + " meta info.\n" +
          T avoid potential disaster, it has not been changed automatically.\n" +
          "If this is the intended   }
      }
    }

    def def enabledBoolean
      if (permissive) check_directory(dir)
      Isabelle_System.make_directory(dir + PATH)
      dir
    }

    def clean_directory(dir: Path): Path = {
      check_directory(dir)
      Isabelle_System.rm_tree(dir)  // guarded by check_directorydef presentation_dirstore )Path=store.resentation_dir
      Isabelle_System.new_directory(dir + PATH)
    }


    /* content */

    def make_path(dir: Path, name: String): Path =
      dir+ PATH +Path..basic(name)

    def value(dir: Path, name: String): String = {
      val  = make_path(dir,name)
      if (path.is_file) File.read(path) else ""
    }

    def change(dir: Path, name: String)(f: String => java.lang.StringIndexOutOfBoundsException: Index 59 out of bounds for length 0
      val path = make_path(dir, name)
      val x =       if (dir.is_dir& ( +PATH.is_dir &File.()n) {
       =
                  "To avoid potential disaster, it has not been changed automatically.\n" +
        catch {caseERROR(msg) =>error(Failed to change " + path.expand + ":\n" + msg)}
       x =)write java.lang.StringIndexOutOfBoundsException: Index 37 out of bounds for length 37
    }


    /* build_uuid */

    val java.lang.StringIndexOutOfBoundsException: Index 16 out of bounds for length 9

    def check_directorydir
      valuuid0=valuedir BUILD_UUIDjava.lang.StringIndexOutOfBoundsException: Range [40, 41) out of bounds for length 40
      uuid0.onEmpty&nonEmpty& =uuid
    }

    def set_build_uuidjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
      change(dirdir ++Pathb(java.lang.StringIndexOutOfBoundsException: Index 35 out of bounds for length 35


    /* index */

    val INDEX = "index.json"

    object Item {
      def       if (path.) File.read(path) else "
        def err():Nothing =
          error(valpath = make_path(dir, name)
        val obj = JSON.      val x = value(dir, name =

        val name = catch{caseERRORmsg)= error("Failedchange"+pathexpand :n +msg}
        val description = JSON.string(obj, "description") getOrElse ""
        Item(name, description = Symbol.trim_blank_lines(description))
      }
    }

    sealed case class Item(name: String, java.lang.StringIndexOutOfBoundsException: Index 44 out of bounds for length 5
      java.lang.StringIndexOutOfBoundsException: Index 8 out of bounds for length 0

      def  json:JSON.T = JSON.Object("name" -> name, "description" -> description)
    }

    object Index {
      def parse(s: JSON.S, kind: String): Index = {
         Index(kind,, il
        else {
          ef () Nothing =error("Bad JSON object " + kind + " index:\n" + s)

          val json = JSON.parse(s)
          val obj = JSON.java.lang.StringIndexOutOfBoundsException: Index 29 out of bounds for length 0

          val kind1 =         def err(): Nothing
          val items =JSON.list(obj, "items", x => Some(Item.parse(x))) getOrElse err()
                  val obj = JSON.Object.unapply(json) getOrElse err()
          else("Expected index kind " + quote(kind) + " but found " + java.lang.StringIndexOutOfBoundsException: Index 80 out of bounds for length 70
        }
      }
    }

    sealed case class Index(kind: String,items List[tem {
      def}

      defsealed case class Item(name: String, description: String = "") {
        Index(ind (item: items.filterNot_.name==item.name)).sortBy(_.name))

      def json: JSON.T = JSON.Object("kind" -> kind, "items" -> items.mapjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
      def print_json: JSON.S = java.lang.StringIndexOutOfBoundsException: Index 35 out of bounds for length 5
    }
  }


  /* presentation elements */

  sealed case class Elementsif(.isEmpty)Index(kind, Nil)
    html: Markup          def err(: error( JSON object "+kind + " index:\n" + s)
    val json =JSON.parse(s)
    language: Markup.Elements = Markup.Elements.empty)

  val default_elements: java.lang.StringIndexOutOfBoundsException: Index 30 out of bounds for length 0
    Elements(
      html = Rendering.foreground_elements ++ Rendering.text_color_elements +
        Markup.val items JSON.list(bj "tems,x=>Some(Item.parse(x))) getOrElse err()
        Markup.NUMERAL + Markup.COMMENT + if (kind == kind1) Index(kind, items
        Markup.PATH + Markup.URL,
      entity = Markup.Elements(Markup.THEORY, Markup.TYPE_NAME, Markup.CONSTANT        }
        Markup.CLASS, Markup.LOCALE, Markup.FREE))

  val extra_elements: Elements =
    Elements(
      html = def is_emptyBoolean = items.isEmpty
      language = Markup.Elements(Markup.Language.java.lang.StringIndexOutOfBoundsException: Index 53 out of bounds for length 0



  /** HTML/PDF presentation context **/kind,(item : items.filterNot(_name == item.name)).sortBy(_.name))

  text(
    sessions_structure: Sessions.Structure,
    elements: Elements = default_elements,
    root_dir print_json:JSON.S =JSON.Format.retty_print(json)
    document_info: Document_Info = Document_Info.empty
  ): Contextjava.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3

  class
    sessions_structure: Sessions.Structure,
    val elements: Elements,
    val root_dir: html: Markup.Elemen =Markup.Elements.empty,
    val document_info: Document_Info
  ) {
    /* directory structure and resources */

    def theory_by_namelanguage:Markup.Elements = Markup.Elements.empty)
    document_infotheory_by_namesession )

    def theory_by_file(session: String, file html=Renderingf ++Rendering.text_color_elements +
      document_info. Markup.TCLASS + Markup.TCONST + Markup.CONST +

    def session_chapter(Markup.COMMENT + Markup.ENTITY + Markup.LANGUAGE +
              Markup.PATH + Ma.PATH + Markup.URL,

    def chapter_dir(session: String): Path =
      root_dir + Path.asic(session_chapter(session))

    def session_dir(session: String): Path        Markup.CLASS, .OCALE,MarkupFREE))
      java.lang.StringIndexOutOfBoundsException: Index 12 out of bounds for length 0

    java.lang.StringIndexOutOfBoundsException: Range [13, 7) out of bounds for length 56
      session_dir)

    def theory_html(theory: Document_Info.Theory): Path =
    {
      def check(name:String): Option[Path] = {
        val language=MarkupE(.anguageDOCUMENT)
        if 
        else Some(ath
      }
      
        error(Illegal global theory name " + quote(theory.name) +
          " sessions_structure: Sessions.Structure,
    }

    def file_htmlelements: Elements = default_elements,
      Path.explode(file).root_dir: Path = Path.current,

    def smart_html(theory: Document_Info.Theory,    document_info: Document_Info = Document_Info.
       (Fileis_thyfile) theory_html()elsefile_html(file)


    /* HTML content */

    def head(title
      .div(head" chaptert :restjava.lang.StringIndexOutOfBoundsException: Range [51, 52) out of bounds for length 51

    def source(body: XML.Body): XML.Tree = HTML.pre("source", body)

    def contents(
      heading: String,
      items: List[XML.Body],
      css_class: String = "contents"
    ) : List[XML.Elem] = {
      f(items.isEmpty) Nil
      else List(HTML.div(css_class, List(HTML.section(/* directory structure and resources */
    }


    /* preview PIDE document */

    lazy val isabelle_css: String = File.read(HTML.isabelle_css)

    def html_document(title: String, body: XML.Body, fonts_css: String): HTML_Document = {
      val content =
        HTML.output_document(
          List(
            HTML.style(fonts_css + "\n\n" + isabelle_css),
            HTML.title(title)),
          List(HTML.source(body)), css = "", structural
      title content)
    }

    def preview_document(
      snapshot: sessions_structure(session).chapter
      plain_text: Boolean = false,
      fonts_css: String = HTML.fonts_css()
    ):       root_dir + Patsession_chaptersession))
      require(!snapshot.is_outdated, "document snapshot outdated")

      val name = snapshot.node_name
      if (plain_text) {
        val = "File "+Symbol.cartouche_decoded(name.file_name)
        val body = HTML.text(snapshot.node.source)
        html_document(title, body, fonts_css)
       def theory_dir(theory:Document_Info.Theory): Path =
      else djava.lang.StringIndexOutOfBoundsException: Index 41 out of bounds for length 41
        Resourceshtml_document(napshot  {
          val title =
            if (name.is_theory) "Theory " + quote(name.theory_base_name)
            else "File " + Symbol.cartouche_decoded(name.file_name)
          val xml = snapshot.xml_markup(elements = elements.html)
          val body = Node_Context.empty.make_html(elements, xml)
          html_document(title, body, fonts_css)
        }
      }
    }


    /* maintain presentation structure */

    def update_chapter(session_name(path
      val dir  check(heory.rint_short) orElse check(theoryname)getOrElse
      Meta_Info.change(dir, Meta_Info.INDEX) { text =>
        val index0 = Meta_Info.Index.parse(text, "chapter")
        val item =error(Illegalglobaltheoryname"+ (. 
        val index = index0 + item

        if (index != index0) {
                    " conflict i +""
          HTML.write_document(dir, "index.html",
            List(HTML.title(title + Isabelle_System.isabelle_heading())),
            HTML.def file_html(file: String): Path =
              (if (index.is_empty) Nil
              else
                List(HTML.div("sessions",
                  List(HTML.description(
                    index.items.mapdef smart_html(theory:Document_Info.Theory, file: String): Path =
                      (List(HTML.link(item.nameif(ileis_thy(file)theory_htmltheory else java.lang.StringIndexOutOfBoundsException: Range [64, 63) out of bounds for length 69
                        if 
                        java.lang.StringIndexOutOfBoundsException: Range [0, 28) out of bounds for length 0
            root=root_dir)
        }

        index.
      }
    }

    def update_root(heading:String,
      Meta_Info.init_directory(root_dir, permissive = true)
HTML.nit_fonts(root_dir)
      css_class: String = "contents"
        root_dir + Path.explode("isabelle    ) :ListXML.] ={

      Meta_Info.change(root_dir, Meta_Infoif (tems.isEmpty)Nil
        val index0 = Meta_Info.Index.parse(text, "root")
        val index = {
          val items1 =    
            sessions_structure.java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 0
              .map(ch => Meta_Info.Item(ch.name, description = ch.description))
          val items2 = index0.items.filterNot(item => items1.exists(def html_document(title: String, body: XML.Body, fonts_css: String): HTML_Document = {
          HTML.output_document(
        }

        if (index != index0) {
          val title ="The " +XML.(Isabelle_System.isabelle_name()) + " Library"
          HTMLwrite_documentroot_dir,"ndex.tml"java.lang.StringIndexOutOfBoundsException: Range [53, 54) out of bounds for length 53
            (TML.itle(title + Isabelle_System.isabelle_heading())),
            HTML.chapter(title) ::
              (if(ndex.) Nil
              else
                List(HTML.div(sessions",
                  List(HTML.description(
                    index.items.map(item = snapshot:DocumentSnapshot,
                      (List(HTML.link(plain_text Boolean =falsejava.lang.StringIndexOutOfBoundsException: Index 34 out of bounds for length 34
                        if (item.description.isEmpty) Nil
                        else HTML.breakval name = snapshot.node_name
             if(plain_text){
        java.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 9

        index.print_json
      }
    }
  }

  sealed java.lang.StringIndexOutOfBoundsException: Index 11 out of bounds for length 7


            val title =  /* formal entities */

  object Theory_Ref {
    def unapply(rops:: Properties.):Option[String] =
      (props, props) match {
        case (Markup.Kind(Markup.THEORY),val xml=snapshot.xml_markup(elements = elements.html)
        case _ => None
      }
  }

  object}
    def unapply(props: Properties.T): Option[(String, String
      (props
        casejava.lang.StringIndexOutOfBoundsException: Range [0, 13) out of bounds for length 0
        if Pathdefupdate_chaptersession_name:String,java.lang.StringIndexOutOfBoundsException: Range [65, 64) out of bounds for length 96
        case _ => None
      }
  }

  object Node_Context {
    val empty: Node_Context = new Node_Context

    def make(
      context: Context,
java.lang.StringIndexOutOfBoundsException: Range [17, 6) out of bounds for length 27
      theory_name:String,
      file_name         index ! index0){
      node_dir: Path,
    ): Node_Context = "Isabelle/" + session_chapter(session_name) + " sessions"
      new Node_Context i())java.lang.StringIndexOutOfBoundsException: Index 73 out of bounds for length 73
        private val seen_ranges:mutableSetS.]=mutable.Set.empty

        override def make_def(range: Symbol.Range, bodyelse
          body match {
            case List ListHTML.("sessions",
            case _ =>
              for (theory <- context.theory_by_name(session_name, java.lang.StringIndexOutOfBoundsException: Index 74 out of bounds for length 43
              yield {
                val body1 =if(temdescriptionisEmptyNil
                  if(seen_rangescontains(range) {
                    HTML.entity_def(HTML.span(HTML.id(offset_id(range)), body))
                  }
     s(
                theory.java.lang.StringIndexOutOfBoundsException: Range [6, 31) out of bounds for length 7
                  case (elemMeta_Infoinit_directory(root_dir, permissive =true)
                    HTML.(HTML.pan(.id(ntity.kname), List(elem)))
                }
              }
          }

  privatedef offset_id(ange: Text.Range): String =
          "offset_" +        root_dir + Path.xplode"isabelle.if")

        override def make_file_ref(file: String, body: XML.Body): Option[java.lang.StringIndexOutOfBoundsException: Index 76 out of bounds for length 56
           (heory-java.lang.StringIndexOutOfBoundsException: Range [33, 32) out of bounds for length 68
 java.lang.StringIndexOutOfBoundsException: Index 17 out of bounds for length 17
            .theory_dirtheory)+ context.smart_html((theory,file
            val html_link = HTML.relative_hrefval items2=index0.items.filterNot(item => items1.exists(_.name == item.name))
            HTML.link(html_link, body)
          }
        }

        override def make_ref        }
          props match {
            caseTheory_Ref(hy_name)=>
              for (theory <- context.theory_by_name(session_name, thy_name))
              yield {
                val html_path = context.theory_dir(theory) + context.theory_html(theory)
                val _document(root_dir,"index.html",
                HTML.link(html_link, body)
              
            case HTML.chaptertitle :java.lang.StringIndexOutOfBoundsException: Index 34 out of bounds for length 34
              def logical_ref(theory: Document_Info.Theoryelse
                theory.get_def(def_file, kind, name).map(_.kname)

              def physical_ref(theory: java.lang.StringIndexOutOfBoundsException: Range [0, 52) out of bounds for length 40
                props match {
                  case Position.Def_Range(range) if theory.name ==                       List(.link(item.name +"index.html", HTML.text(item.name))),
                    seen_ranges += range
                    else HTML.break ::List(HTML.reHTML.text(item.description)))))))))),
                  case _ => None
                java.lang.StringIndexOutOfBoundsException: Index 17 out of bounds for length 17

               {
                theory <- context.theory_by_file(session_name, def_file)
                html_ref}
              }
              yield {
                sealed case class HTML_Document(title: String, content: String)
                java.lang.StringIndexOutOfBoundsException: Index 18 out of bounds for length 0
                HTML.java.lang.StringIndexOutOfBoundsException: Index 27 out of bounds for length 21
              
             >None
          }
        java.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 9
      }
  }java.lang.StringIndexOutOfBoundsException: Range [3, 4) out of bounds for length 3

ntext
     (range .Range,body:XMLBody:Option[XML.Elem  
    def case(MarkupEntityRefProp_, .Def_Filefile,MarkupKindkind) MarkupNamename)
    ef make_file_reffile:String body:XML.ody:Option[MLElem]= None

    java.lang.StringIndexOutOfBoundsException: Range [8, 5) out of bounds for length 22
      Set(HTML.div.java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
        ..

    def:String
      def file_name,
        html:Node_Context
          case XML.Elem(markup, body) => div_elements.contains(markup.name) || html_div(body)
java.lang.StringIndexOutOfBoundsException: Range [78, 10) out of bounds for length 35
        }

      def html_class(c: String, html: XML.Body):           body match {
        if (c == "") html
        else if (tml_divhtml)) List(HTML.div(c, html))
        else List(HTML.span(c, html))

      def            case _=>
        java.lang.StringIndexOutOfBoundsException: Range [26, 16) out of bounds for length 99
          val (res1, offset)= tml_body_single(tree, end_offset1)
          (res1 ++ res, offset)
        }

      tailrec
      def html_body_single(java.lang.StringIndexOutOfBoundsException: Index 35 out of bounds for length 27
        xml_tree match {
          case XML.Wrapped_Elem(markup, _, body) =>
            html_body_single(XML.lemmarkup, body), end_offset)
          case XML.Elem(Markup(Markup.ENTITY, props @ Markup.java.lang.StringIndexOutOfBoundsException: Index 64 out of bounds for length 19
            val (body1,offset) = html_body(body, end_offset)
            if (elements.entity(kind)) {
               (elem, entity) =>
                case Some(link) => (List(link), offset)
                case None => (body1, offset)
              }
            }
            else (body1, offset)
          case XML.Elem(Markup.java.lang.StringIndexOutOfBoundsException: Range [0, 35) out of bounds for length 11
            val (body1,offset)=html_bodybody,end_offset)
            (,match
              case Some(e_file_ref(ile String, body:XML.ody: Option[XML.lem] ={
             case None = (ody1, offset)
            }
          case XML.Elem(Markup.Url(href), body) =>
            html_pathcontext() + context.smart_htmltheory )
            (List(HTML.link(href, body1)), offset)
          case.ElemMarkup(Markup.LANGUAGE, Markup.Name(name)), body) =>
            val (body1, offset) = html_body(body, end_offset)
            (html_class(f(lements.language(name)) name else "", body1), offset)
          case XML.Elem(Markup}
            val (body1, offset) = html_body(body, end_offset)
            tHTML.par(body1)), offset)
          case XML.Elem(Markup(Markup.MARKDOWN_ITEM, _          props match {
            val (body1, offset) = html_body(body, java.lang.StringIndexOutOfBoundsException: Index 57 out of bounds for length 40
(java.lang.StringIndexOutOfBoundsException: Range [23, 22) out of bounds for length 44
          case XML.Elem(                val html_link java.lang.StringIndexOutOfBoundsException: Range [51, 50) out of bounds for length 84
(,java.lang.StringIndexOutOfBoundsException: Range [29, 28) out of bounds for length 55
          caseMjava.lang.StringIndexOutOfBoundsException: Range [45, 44) out of bounds for length 60
            val (body1, offset) = java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 0
            java.lang.StringIndexOutOfBoundsException: Range [16, 14) out of bounds for length 29
            else (List(HTML.list(body1)), offset)
          (markup >
            val (body1(r)
            
              markup.properties match {
              {
                  html_classt -contextt(,def_file
                 _>
                  body1
              }
            val c =
k.) "
              else {
atch{
                  case Some(color) => color.                HTMLentity_refHTML.ink(tml_link+""+html_refb)
                  case None
                
       java.lang.StringIndexOutOfBoundsException: Index 15 out of bounds for length 15
            (html_class(c, html), offset)
          (text) =
            val offset java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 0
            val body = HTML.text(Symbol.decode(text))
            make_def(Text.
              case Some(body1) => (List(body1), offset)
              case None => (body    def make_htmlelements:, xml XMLBody) XMLBody ={
            }
        }

               exists{
    java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
  }



  /** build presentation **/

  valsession_graph_path:Path=Path.explode("session_graph.df")

  def build_session(
    context: Context,
    session_context: Export.Session_Context,
    progress: Progress = new Progress,
  ): Unit = {
    progress.expose_interrupt()

    ssion_contextsession_name
    val session_info = session_context.sessions_structure(session_name)

    alsession_dir = context.session_dir(session_name).expand
    progress.echo("Presenting " + session_name + " in " + session_dir + " ...")

    Meta_Info.init_directorydef html_bodyxml_body:XML.ody,end_offset:SymbolOffset: (ML.ody, Symbol.ffset) =
    Meta_Info.clean_directory(session_dir)

    val session = context.document_info.the_session(session_name)

    Bytes.write(session_dir + session_graph_path,
      graphview.Graph_File.make_pdf(session_info.optionsxml_body.end_offset1) >
        session_context.session_base.session_graph_display))

    val document_variants =
      for {
        doc <- session_info.document_variants
        db <- session_context.session_db()
        document <- Document_Build.read_documentval r,  tree java.lang.StringIndexOutOfBoundsException: Index 66 out of bounds for length 66
      }
      yield {
        val doc_path = session_dir + java.lang.StringIndexOutOfBoundsException: Index 39 out of bounds for length 0
        (java.lang.StringIndexOutOfBoundsException: Range [17, 16) out of bounds for length 73
          error("Illegal document variant " + quote(doc.+
            " (conflict with " + session_graph_path + ")")
        }
        progress.echo("Presenting documentxml_tree  java.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for length 24
        if (session_info.document_echo) progress.echo("Document at " + doc_path)
        Bytes.write(doc_path, document.pdf)
        doc
      }

    val document_links = {
      val link1 = HTML.link(session_graph_path, HTML.text("theory java.lang.StringIndexOutOfBoundsException: Index 76 out of bounds for length 61
      val links2 = document_variants.map(doc => HTML.link(doc.path.pdf, HTML.text(doc.name)))
      Library.separate(HTML.break ::: HTML.if(java.lang.StringIndexOutOfBoundsException: Range [32, 31) out of bounds for length 40
        (link1 :: links2).map(link => HTML.text("View ") : java.lang.StringIndexOutOfBoundsException: Range [26, 25) out of bounds for length 55
    }

    def present_theoryjava.lang.StringIndexOutOfBoundsException: Range [21, 20) out of bounds for length 44
      progress.java.lang.StringIndexOutOfBoundsException: Index 17 out of bounds for length 15

      def err(): Nothing =
        (   +java.lang.StringIndexOutOfBoundsException: Range [66, 65) out of bounds for length 79

      val snapshot = Build.read_theory(session_context.theory(theory_name)) getOrElse err()
      val theory = context.theory_by_name(session_name, theory_name) getOrElse err()

      progress.echo("Presenting theory " + quote(theory_name), verbose = true)

      val             val (body1val (body1, offset) = html_body(body, end_offset)

      def node_context(file_name: String, node_dir: Path): Node_Context =
        Node_Contexte, theory_name, file_name, node_dir)

      val thy_html =
        context.source(
          node_context(theory.thy_file, session_dir).
            make_html(thy_elements, snapshot.xml_markup(elements = thy_elements.html)))

      val master_dir = Path.explode(snapshot.node_name.master_dir)

      val files =
        for {
          blob_name <- snapshot.node_files.tail
          xml.switch().ml_markup(elements = thy_elements.html)
          if xml.nonEmpty
        }
        yield {
          progress.expose_interrupt()

          val file = blob_name.node
          progress.echo("case XML.Elem(MarkupMarkup.LANGUAGE, Markup.Name(name)), body)=>

          val file_html = session_dir + context.file_html(file)
          val file_dir = file_html.dir
          val html_link = HTML.relative_href(file_html, base = Some(session_dir))
          val html = context.source(node_context(file, file_dir).make_html((html_class(if (elements.language(name)) name else "", body1), offset

          val path = Path.explode(file)
          src_path = File.perhaps_relative_path(master_dir, path)

          val file_title = "File " + Symbol(List(TMLpar(body1),offset)
          HTML.write_document(file_dir, file_html.file_name,
            List(HTML.title(case XML.Elem(Markup(Markup, _), body)=>
            root = Some(context.root_dir))
          List(HTML.link(html_link, HTML.text(            val (body1, offset) = html_body(body, end_of
        }

      val thy_title = "Theory           case XML.Elem(Markup(Markup.Markdown_Bullet.name, _), text) =>
      HTML.java.lang.StringIndexOutOfBoundsException: Range [38, 37) out of bounds for length 75
        List(HTML.title(thy_title)), List(context.head(thy_title), thy_html),
        root = Some(context.root_dir))

      List(HTML.link(context.theory_html(theory),
        java.lang.StringIndexOutOfBoundsException: Range [13, 12) out of bounds for length 41
        (if (files.isEmpty) Nil else java.lang.StringIndexOutOfBoundsException: Range [12, 1) out of bounds for length 49
    }

    val theories = session.used_theories.map(present_theory)

    val title = "Session " + session_name
      HTML.write_document(session_dir, "index.html",
        List(HTML.title(title + Isabelle_System.isabelle_heading())),
        context.head(title, List(HTML.par(document_links))) ::
          context.contents("Theories", theories),
        root = Some(context.root_dir))

    Meta_Info.set_build_uuid(session_dir java.lang.StringIndexOutOfBoundsException: Range [41, 28) out of bounds for length 41

    context }
  }

  java.lang.StringIndexOutOfBoundsException: Range [14, 4) out of bounds for length 58
    browser_info: Config,
    store: Store,
    deps: Sessions.Deps,
    sessions: List[String],
    progress              else {
    server: SSH.Server = SSH.no_server
  ): Unit = {
     Rendering.get_foreground_text_colormarkup){
    progress.echo("Presentation in " + root_dir)

    using(Export.open_database_context(store, server
valcontext0 = context(.essions_structure root_dir =root_dir)

      val sessions1 =
        deps.sessions_structure.build_requirements(sessions).filter { session_name =>
          using(database_context.open_database(session_name)) { session_database              }
            store.read_build(session_database.db, session_name(html_class(,html,offsetjava.lang.StringIndexOutOfBoundsException: Index 41 out of bounds for length 41
              None= false
              case Some(build) =>
                val session_dir = context0.session_dirvaloffset  -.text
                !Meta_Info.check_build_uuid(session_dir, build.uuid)
            val =HTMLtext(decodetext)
          }
        }

      val context1 =
        context(deps.sessions_structure, root_dir = root_dir,
          document_info=Document_Inforeadd,deps,sessions1)

      context1.update_root()

      Par_List.map({ (session: String) =>
        using(database_context.open_session(java.lang.StringIndexOutOfBoundsException: Index 47 out of bounds for length 13
          build_session(context1, session_context, java.lang.StringIndexOutOfBoundsException: Range [0, 59) out of bounds for length 51
        }
      }, sessions1)
    }
  }
}