Fossil

      // Force UI update
      s.dispatchEvent(new Event('change',{target:s}));
    }
  };

  const WikiList = {
    e: {},
    /** Updates OPTION elements to reflect whether the page has
        local changes or is new/unsaved. */
    refreshStashMarks: function(){
      const sel = this.e.select;

      Object.keys(sel.options).forEach(function(key){
        const opt = sel.options[key];
        const stashed = $stash.getWinfo({name:opt.value});
        if(stashed){
          const isNew = 'sandbox'===stashed.type ? false : !stashed.version;
          D.addClass(opt, isNew ? 'stashed-new' :'stashed');
        }else{
          D.removeClass(opt, 'stashed', 'stashed-new');
        }
      });
    },
    /** Removes the given wiki page entry from the page selection
        list, if it's in the list. */
    removeEntry: function(name){
      const sel = this.e.select;
      const ndx = sel.selectedIndex;
      sel.value = name;
      if(sel.selectedIndex>-1){
        sel.options.remove(sel.selectedIndex);
      }
      sel.selectedIndex = ndx;
    },
    /**
       Installs a wiki page selection list into the given parent DOM
       element and loads the page list from the server.
    */
    init: function(parentElem){
      const sel = D.select(), btn = D.button("Reload page list");
      this.e.select = sel;
      D.addClass(parentElem, 'wikiedit-page-list-wrapper');
      D.clearElement(parentElem);
      D.append(
        parentElem,
        D.append(D.span(), "Select a page to edit:"),
        sel,
        D.append(D.span(), "[*] = page has local edits"),
        D.append(D.span(), "[+] = page is new/unsaved"),
        btn
      );
      D.attr(sel, 'size', 10);
      D.option(D.disable(D.clearElement(sel)), "Loading...");
      const self = this;
      btn.addEventListener(
        'click',
        function click(){

        false
      );
      F.page.addEventListener(
        'wiki-stash-updated',
        ()=>this.refreshStashMarks(),
        false
      );
      delete this.init;
    }
  };

  /**
     Keep track of how many in-flight AJAX requests there are so we
     can disable input elements while any are pending. For
     simplicity's sake we simply disable ALL OF IT while any AJAX is

    F.confirmer(P.e.btnReload, {
      confirmText: "Really reload, losing edits?",
      onconfirm: function(e){
        const w = P.winfo;
        if(!w){
          F.error("No page loaded.");
          return;
        }
        if(!w.version/* new/unsaved page */ && P.wikiContent()){
          F.error("This new/unsaved page has content.",
                  "To really discard this page,",
                  "first clear its content",
                  "then use the Discard button.");
          return;
        }
        P.unstashContent()
        if(w.version){
          P.loadPage();
        }else{
          delete P.winfo;
          WikiList.removeEntry(w.name);
          P.updatePageTitle();
          F.message("Discarded new page ["+w.name+"].");
        }
      },
      ticks: 3
    });
    P.e.taEditor.addEventListener(
      'change', ()=>P.stashContentChange(), false
    );
    

  */
  const affirmPageLoaded = function(quiet){
    if(!P.winfo && !quiet) F.error("No wiki page is loaded.");
    return !!P.winfo;
  };

  /**
     Update the page title and header based on the state of
     this.winfo. A no-op if this.winfo is not set. Returns this.
  */
  P.updatePageTitle = function f(){

    if(!f.titleElement){
      f.titleElement = document.head.querySelector('title');
      f.pageTitleHeader = document.querySelector('div.header .title');
    }
    var title = ['Wiki Editor:'];
    if(P.winfo){
      if(!P.winfo.version) title.push('[+]');
      else if($stash.getWinfo(P.winfo)) title.push('[*]')
      title.push(P.winfo.name);
    }else{
      title.push('(no page loaded)');
    }
    title = title.join(' ');
    f.titleElement.innerText = title;
    f.pageTitleHeader.innerText = title;
    return this;
  };
  
  /**
     Getter (if called with no args) or setter (if passed an arg) for
     the current file content.

     The setter form sets the content, dispatches a

      /* Assume winfo-like object */
      const arg = arguments[0];
      name = arg.name;
    }
    const onload = (r)=>this.dispatchEvent('wiki-page-loaded', r);
    const stashWinfo = this.getStashedWinfo({name: name});
    if(stashWinfo){ // fake a response from the stash...
      F.message("Fetched from the local-edit storage:",
                stashWinfo.name);
      onload({
        name: stashWinfo.name,
        mimetype: stashWinfo.mimetype,
        type: stashWinfo.type,
        version: stashWinfo.version,
        parent: stashWinfo.parent,
        content: $stash.stashedContent(stashWinfo)
      });


      return this;
    }
    F.message(
      "Loading content..."
    ).fetch('wikiajax/fetch',{
      urlParams: {
        page: name
      },
      responseType: 'json',
      onload:(r)=>{

        F.message('Loaded page ['+r.name+'].');
        onload(r);
      }
    });
    return this;
  };
  
  /**
     Fetches the page preview based on the contents and settings of