/************************************
  REVISION LOG ENTRY
  Revision By: Mihai Filimon ( mfl@exontrol.com )
  Created on 11/23/2020 10:00:00 AM
  Modified on 02/25/2022 11:00:00 AM (*Added: Include the "title" (description) and "data-values" (values of an enumeration type) attributes of the <a> inside of LI element, while filtering. Currently, the filter includes the property, method, event or type's name, description and values (for enumeration types) (enum type includes each defined constants such as <a href="CheckStateEnum_enum.htm" data-values="Unchecked(0),Checked(1),PartialChecked(2)">CheckStateEnum</a>))
  Modified on 09/19/2022 10:50:00 AM (includes support for @media only screen and (max-width: 580px))
  Modified on 06/18/2024 09:30:00 AM (*Fixed: The resizing of the navbar section of the frame pauses when the cursor hovers over the content area (right panel))
  Modified on 11/07/2025 09:30:00 AM (*NEW: Highlights matches and filters the document while typing)
  Modified on 02/20/2026 09:30:00 AM (*Added: Toggles the filter highlighting in the main content on double-click or keydown (for accessibility) events, to quickly show/hide the filter highlights in the content-document (@since 26.02))

  Comments: help.js, help.css

  This code may be used in compiled form in any way you desire. This
  file may not be redistributed modified or unmodified without the authors
  written consent.
  ************************************/

(function (callback)
{
  callback();
}((function ()
{
  'use strict';

  /////////////////////////////////////////////////////////// (QP) (QueryParam)
  //
  // The QP namespace provides functions to update or query the URL parameters. 
  //
  // The QP namespace includes definitions for the following methods:
  //
  //  Split(url) {object}, splits the URL into location, params and hash parts, as an object of {a(ll),u(rl),h(ash),l(ocation),p(arams)} type
  //  Add(url, param, value) {string}, adds(replaces) the parameter of the specified url and returns the new url(adds/replaces "param=value" or "param")
  //  Del(url, param) {string}, removes the parameter of the specified url and returns the new url
  //  Has(url, param) {string}, gets the value of the specified parameter within the giving url (returns null if no parameter is found)
  //
  ///////////////////////////////////////////////////////////

    /**
     * @description Creates the QP namespace
    */
    var QP = function()
        {
          /**
           * @description The split() method splits the URL into location, params and hash parts, as an object of {a(ll),u(rl),h(ash),l(ocation),p(arams)} type
           * @param {string} url A string expression that defines the URL to split
           * @returns {object} Returns an object of {a(ll),u(rl),h(ash),l(ocation),p(arams)} type as explained:
           * 
           *  a(ll) {string}, indicates the unsplited URL (as it was provided)
           *  u(rl) {string}, specifies the URL without the # hash section (location + params)
           *  h(ash) {string}, indicates empty string or the # hash section (includes the '#' character)
           *  l(ocation) {string}, specifies the location of the URL (the string precceding the ? character, includes protocol, domain and path)
           *  p(arams) {string}, specifies the query-parameters of the URL (the string after the ? character, includes '?' character)
           * 
          */
          function split(url)
          {
            var iHash = String(url || "").indexOf('#'),         // {number} indicates the position of '#' character within the url (-1 if not found)
                u = ~iHash ? url.substr(0, iHash).trim() : url, // {string} specifies the URL without the # hash section (location + params)
                iParam = u.indexOf('?');                        // {number} indicates the position of '?' character within the url (-1 if not found)
            return {
              a: url,                                           // a(ll) {string}, indicates the unsplited URL (as it was provided)
              u: u,                                             // u(rl) {string}, specifies the URL without the # hash section (location + params)
              h: ~iHash ? url.substr(iHash).trim() : "",        // h(ash) {string}, indicates empty string or the # hash section (includes the '#' character)
              l: ~iParam ? u.substr(0, iParam).trim() : u,      // l(ocation) {string}, specifies the location of the URL (the string precceding the ? character, includes protocol, domain and path)
              p: ~iParam ? u.substr(iParam).trim() : "",        // p(arams) {string}, specifies the query-parameters of the URL (the string after the ? character, includes '?' character)
            }
          }

          /**
           * @description The getParamEx() method gets the regular-expression to search for the parameter
           * @param {string} param Specifies the name of the parameter to look for
           * @returns {object} Returns an object of RegExp type
          */
          function getParamEx(param)
          {
            return new RegExp("[?&]" + param + "($|[&]|=[^&]*)", "i");
          }

          /**
           * @description The add() method adds(replaces) the parameter of the specified url (adds/replaces "param=value" or "param")
           * @param {string} url Specifies an URL to change
           * @param {string} param Indicates the name of the parameter to add
           * @param {string} value Specifies the value of the parameter to add
           * @returns {string} Returns the new URL (includes the added parameter)
          */
          function add(url, param, value)
          {
            var oURL = split(url),
                oParamEx = getParamEx(param = String(param || "").trim()),
                separator = oURL.u.indexOf('?') != -1 ? "&" : "?",
                oMatch = oURL.u.match(oParamEx);

            // builds the value as "param=value" or "param"
            if ( value = String(value || "").trim() )
              value = "=" + value;
            value = param + value;

            // adds or replaces the parameter
            return (oMatch ? oURL.u.substr(0,oMatch.index + 1) + value + oURL.u.substr(oMatch.index + oMatch[0].length) : oURL.u + separator + value) + oURL.h
          }

          /**
           * @description The del() method removes the parameter of the specified url
           * @param {string} url Specifies an URL to change
           * @param {string} param Indicates the name of the parameter to delete
           * @returns {string} Returns the new URL (excludes the parameter)
          */
          function del(url, param)
          {
            var oURL = split(url);
            url = oURL.u.replace(getParamEx(String(param || "").trim()), '');

            if (url.slice(-1) == '?')
              url = url.slice(0, -1); // removes the last ? character if any

            if (url.indexOf('?') < 0)
              url = url.replace(/&/, '?'); // replace the first occurrence of & by ? if no ? is present

            return url + oURL.h;
          }

          /**
           * @description The has() method gets the value of the specified parameter within the giving url (returns undefined if no parameter is found)
           * @param {string} url Specifies an URL to query
           * @param {string} param Indicates the name of the parameter to request
           * @returns {string} Returns null (no parameter found), or a string expression that defines the value of the giving parameter (could be empty string)
          */
          function has(url, param)
          {
            var oParam = split(url).u.match(getParamEx(param = String(param || "").trim())),  // {array} returns the matches, as an Array object
                nEqual;                                                                       // {number} specifies the position of the "=" character inside the match

            if ( oParam )
            {
              oParam = oParam[0];
              nEqual = oParam.indexOf("=");
              oParam = ~nEqual ? oParam.substr(nEqual + 1) : "";
            }
            return oParam;
          }

          return {
            /**
             * @description The Split(url) method splits the URL into location, params and hash parts, as an object of {a(ll),u(rl),h(ash),l(ocation),p(arams)} type
             * @param {string} url A string expression that defines the URL to split
             * @returns {object} Returns an object of {a(ll),u(rl),h(ash),l(ocation),p(arams)} type as explained:
             * 
             *  a(ll) {string}, indicates the unsplited URL (as it was provided)
             *  u(rl) {string}, specifies the URL without the # hash section (location + params)
             *  h(ash) {string}, indicates empty string or the # hash section (includes the '#' character)
             *  l(ocation) {string}, specifies the location of the URL (the string precceding the ? character, includes protocol, domain and path)
             *  p(arams) {string}, specifies the query-parameters of the URL (the string after the ? character, includes '?' character)
             * 
             * @example
             * 
             *  QP.Split("http://exontrol.com/rhelp.jsp?product=exgrid#bookmark") 
             * 
             *    returns: 
             * 
             *  {
             *    a:'http://exontrol.com/rhelp.jsp?product=exgrid#bookmark'
             *    h:'#bookmark'
             *    l:'http://exontrol.com/rhelp.jsp'
             *    p:'?product=exgrid'
             *    u:'http://exontrol.com/rhelp.jsp?product=exgrid'
             *  }
            */
            Split: split,
            /**
             * @description The Add(url, param, value) method adds(replaces) the parameter of the specified url and returns the new url (adds/replaces "param=value" or "param")
             * @param {string} url Specifies an URL to change
             * @param {string} param Indicates the name of the parameter to add
             * @param {string} value Specifies the value of the parameter to add
             * @returns {string} Returns the new URL (includes the added parameter)
             * @example
             * 
             *  QP.Add("http://exontrol.com/rhelp.jsp?product=exgrid#bookmark","src","InsideZooms_default") 
             * 
             *    returns: 
             * 
             *  "http://exontrol.com/rhelp.jsp?product=exgrid&src=InsideZooms_default#bookmark"
            */
            Add: add,
            /**
             * @description The Del(url, param) method removes the parameter of the specified url and returns the new url
             * @param {string} url Specifies an URL to change
             * @param {string} param Indicates the name of the parameter to add
             * @returns {string} Returns the new URL (excludes the parameter)
             * @example
             * 
             *  QP.Del("http://exontrol.com/rhelp.jsp?product=exgrid#bookmark","product") 
             * 
             *    returns: 
             * 
             *  "http://exontrol.com/rhelp.jsp#bookmark"
            */
            Del: del,
            /**
             * @description The Has(url, param) method gets the value of the specified parameter within the giving url (returns null if no parameter is found)
             * @param {string} url Specifies an URL to query
             * @param {string} param Indicates the name of the parameter to request
             * @returns {string} Returns null (no parameter found), or a string expression that defines the value of the giving parameter (could be empty string)
             * @example
             * 
             *  QP.Has("http://exontrol.com/rhelp.jsp?product=exgrid#bookmark","product") 
             * 
             *    returns: 
             * 
             *  "exgrid"
            */
            Has: has
          };
        }(),
      VERSION = "26.03",      // {string} specifies the version of the help system, as "year.month"
      EXPANDED = "expanded",  // {string} specifies the class name to expand the object
      OBJECT = "object",      // {string} specifies the class name that defines an object
      PROPERTY = "property",  // {string} specifies the class name that defines a property
      METHOD = "method",      // {string} specifies the class name that defines a method
      READONLY = "readonly",  // {string} specifies the class name that defines a method
      DISABLED= "disabled",   // {string} specifies the class name that defines a disabled anchor
      TOPIC = "topic",        // {string} specifies the class name that defines a topic
      HIDDEN = "hidden",      // {string} specifies the name of the class for non-visible elements
      ACTIVE = "active",      // {string} specifies the name of the class to activate a "LI" element
      GLYPH = "glyph",        // {string} specifies the name of the class that displays the expand/collapse glyphs
      CLOSE = "close",        // {string} specifies the name of the class/identifier that displays the filter's close button
      PX = "px",              // {string} indicates the px-units
      TOC = "TOC",            // {string} indicates the identifier of the document's `TOC` element (Table of Contents)
      CNT = "CNT",            // {string} indicates the identifier of the document's `CNT` element (Content)
      F = "F",                // {string} specifies the identifier of the DIV that hosts the `Filter` element (Parent-Filter)
      FILTER = "Filter",      // {string} indicates the identifier of the document's `Filter` element (Filter)
      L = "L",                // {string} indicates the identifier of the document's `L` element (Left side)
      R = "R",                // {string} indicates the identifier of the document's `R` element (Right side)
      PARAM =                 // {object} defines the parameters of the current document
      {
        S: "S",               // {string} specifies the source to display (indicates the URL to set for `CNT` element)
        F: "F"                // {string} specifies the current filter
      },
      A = "A",                // {string} holds the <a> elements              
      EOL = "\n",             // {string} defines the EOL character
      INFOTABLE = "InfoTable",                    // {string} indicates the identifier of the document's `InfoTable` element
      FILTERMATCH = "FilterMatch",                // {string} indicates the class name for matched elements
      FILTERMATCHEXCLUDE = "FilterMatchExclude",  // {string} indicates the class name for excluded elements
      WRAP = "WRAP",                              // {string} indicates the class name for wrapped elements
      NAMEVALUEDESC = "Name\tValue\tDescription",
      nCntCounter = 0,  // {number} indicates the number of times the cntHighlightFilter method has been invoked
      duration = 250,   // {number} specifies the speed in ms of the animation for including or excluding literals in the InfoTable
      easing = 'ease',  // {string} controls how the animation progresses over time, such as linear, accelerating, or decelerating.
      lCntFilter;       // {number} stores the current handle of the timer that initiates the cntHighlightFilter

  /**
   * @description The feU/forEachUntil() method invokes the callback for each element of the HTMLCollection object until it returns a truly value (handy function to enumerate the elements of HTMLCollection)
   * @param {callback} callback Specifies the function of callback(oElement) {boolean} type that's invoked for each element
   * @returns {any} Returns undefined or the result of the last callback
  */
  function feU(collection, callback)
  {
    var oResult;
    for ( var oItem of collection ) 
      if ( oResult = callback(oItem) )
        return oResult;
  }

  /*
  function feU(collection, callback)
  {
    var oResult;
    for ( var i = 0, l = collection.length; !oResult && i < l; i++ )
      oResult = callback(collection.item(i));
    return oResult;
  }
  */

  /**
   * @description The getFilter() method builds the filter object used to match values against multiple terms
   * @param {string} filter Specifies the filter string that could include multiple terms separated by space
   * @returns {object} Returns an object of {terms, match()} type as explained:
   * 
   *  terms {array}, holds the regular expressions for each filter term
   *  match(value) {boolean}, method that determines whether the value matches all filter terms
   * 
   * @example
   * 
   *  if ( getFilter("term1 term2").match("This is term1 and term2") )
   *    console.log("The value matches all filter terms");
   * 
  */
  function getFilter(filter)
  {
    /**
     * @description The toFilter() method removes special characters and extra spaces from the filter string to extract the filter terms
     * @param {string} filter Specifies the filter string that could include multiple terms separated by space
     * @returns {string} Returns the processed filter string that contains only the filter terms separated by a single space
    */
    function toFilter(filter)
    {
      return filter && String(filter).replace(/[^0-9a-z]/gi, ' ').trim() || ""; // removes special characters and trims extra spaces, to extract the filter terms
    }

    var rgTerms = [];   // {array} holds the terms by lenght (longest first) to avoid matching smaller terms that are part of larger terms

    // removes special characters and extra spaces from the filter string to extract the filter terms, such as "Item Selected" from "Item.Selected"
    filter = toFilter(filter);

    // splits the filter value to extract terms combined with AND for searching or filtering
    filter && filter.split(" ").forEach(function(value)
    {
      (value = value.trim()) && rgTerms.push(value);
    });

    // sorts the terms by lenght (longest first)
    rgTerms.sort(function(a, b)
    {
      return b.length - a.length;
    });

    // removes duplicate terms or terms that are part of other terms
    rgTerms = rgTerms.filter(function(term, index)
    {
      term = term.toLocaleLowerCase();
      for ( var i = 0; i < index; i++ )
        if ( ~rgTerms[i].toLocaleLowerCase().indexOf(term) )
          return false; // removes the term if it's part of another term
      return true;
    });

    // builds the rgResult result
    return {
      /**
       * @description The terms field holds the regular expressions for each filter term, as an array of [RegExp] type
       * @type {array}
      */
      terms: rgTerms.map(function(term)
      {
        term = term.replace(/[.*+?^${}()|[\]\\]/g, '\\$&'); // escapes special characters for RegExp (prevent 'Uncaught SyntaxError: Invalid regular expression' (#26.02))
        return new RegExp(term, "gi") // {RegExp} m(atch) specifies the regular expression used for searching as g(lobal) and i(gnorecase)
      }),
      /**
       * @description The match() method determines whether the value matches all filter terms
       * @param {string} value Specifies the value to match against all filter terms
       * @returns {boolean} Returns true if the value matches all filter terms, else false
       */
      match: function(value)
      {
        return !feU(this.terms, function(oTerm)
        {
          return !value.match(oTerm);
        })
      }
    }
  }

  /**
   * @description The expEnsureVisible() method expands any collapsed parent elements and scrolls the specified element into view if necessary
   * @param {object} oElement Specifies the element to fit the view's client area (scroll into the view)
  */
  function expEnsureVisible(oElement)
  {
    /**
     * @description The scrollIntoL() method scrolls the element to fit its parent ("L" part) client area
     * @param {object} oElement Specifies the element to fit the view's client area (scroll into the view)
    */
    function scrollIntoL(oElement)
    {
      /**
       * @description The getScrollParent() method determines the parent-element responsible to scroll the element
       * @param {object} oElement Specifies the element to fit the view's client area (scroll into the view)
       * @returns {object} Returns the parent-element responsible to scroll the element
      */
      function getScrollParent(oElement)
      {
        while (oElement && !/(auto|scroll)/.test(getComputedStyle(oElement).overflow) )
          oElement = oElement.parentElement;
        return oElement;
      }

      var rtElement = oElement.getBoundingClientRect(),
          oScrollParent = getScrollParent(oElement),
          rtContainer = oScrollParent.getBoundingClientRect(),
          topFixedHeight = 56,
          bottomFixedHeight = 4 + (oScrollParent.offsetHeight - oScrollParent.clientHeight), // height of the scroll bar
          scrollBy = 0,
          dy = 0;

      if ( (dy = rtElement.top - topFixedHeight) < 0 )
        scrollBy = dy;
      else
        if ( (dy = (rtElement.bottom - (rtContainer.bottom - bottomFixedHeight))) > 0 )
          scrollBy = dy;

      scrollBy && oScrollParent.scrollBy(
      {
        behavior: "smooth",
        top: scrollBy
      })
    }

    if ( oElement )
    {
      var oCL,  // {object} indicates an object of DOMTokenList type that holds classes of the element
          o;    // {object} holds a reference to an HTML element

      // adds `expanded` class to "LI" of `object` class (expand the object that contains the property)
      ((oElement.classList.contains(OBJECT) && (oCL = oElement.classList)) || ((o = oElement.parentElement) /*<ul>*/ && (o = o.parentElement) /*<li>*/ && o.classList.contains(OBJECT) && (oCL = o.classList))) &&
        oCL && 
          oCL.add(EXPANDED);

      // scrolls the element's parent container so the element fits the view's client area
      scrollIntoL(oElement);
    }
  }

  /**
   * @description The ensureVisible() method scrolls the specified element into view if necessary
   * @param {HTMLElement} oElement Specifies the element to fit the view's client area (scroll into the view) 
  */
  function ensureVisible(oElement)
  {
    oElement && 
      oElement.scrollIntoView && 
        oElement.scrollIntoView(
        {
          behavior: "smooth",
          block: "nearest",
          inline: "nearest"
        });
  }

  /**
   * @description The isVerticalSplit() method determines whether the event's pointer hovers the `TOC` vertical-spliter
   * @param {object} event Indicates the event to check its pointer
  */
  function isVerticalSplit(event)
  {
    return event.target.id == L;
  }

  /**
   * @description The syncH/syncronizeHash() method syncronizes the current hash with the CNT's hash
   * @param {object} cnt Specifies the `CNT` element
  */
  function syncH(cnt)
  {
    try
    {
      var hash = wR().location.hash;
      hash && 
        (cnt = (cnt || document.getElementById(CNT))) && 
          cnt.contentWindow && 
            (cnt.contentWindow.location.hash = hash); // forwards the has to `CNT`'s location
    }
    catch(e)
    {
      // Uncaught DOMException: Blocked a frame with origin "protocol://" from accessing a cross-origin frame.
    }
  }

  /**
   * @description The updateclassList() method gets the "add" or "remove" methods of DOMTokenList object
   * @param {boolean} bRemove Specifies a boolean expression to return the "remove", else "add"
   * @returns {string} Returns "remove" or "add" token
  */
  function updateclassList(bRemove)
  {
    return bRemove ? "remove" : "add";
  }

  /**
   * @description The preventDefault() method prevents any default-action
   * @param {object} event Specifies the event to cancel its default-action
  */
  function preventDefault(event)
  {
    event.preventDefault();
    event.stopImmediatePropagation();
    event.stopPropagation();
  }

  /**
   * @description The wR() method returns the root-window
  */
  function wR()
  {
    return window.top;
  }

  /**
   * @description The href() method returns a string which contains the entire URL of the page, including the protocol
   * @returns {string} Returns a string which contains the entire URL of the page, including the protocol
  */
  function href()
  {
    return wR().location.href;
  }

  /**
   * @description The setP() method updates (add,replace or remove) the param's value for the browser's URL
   * @param {string} param Indicates the name of the parametrer to add/replace/remove
   * @param {string} value Specifies the value of the parameter (undefined to remove the parameter)
  */
  function setP(param, value)
  {
    wR().history.replaceState(null, null, QP[value != null ? "Add" : "Del"].call(QP, href(), param, value));
  }

  /**
   * @description The getP() method gets the value of the specified parameter within the browser's URL (returns null if no parameter is found)
   * @param {string} param Indicates the name of the parametrer to request
   * @returns {string} Returns null (no parameter found), or the value of the specified parameter
  */
  function getP(param)
  {
    var result = QP.Has(href(), param);
    if ( result != null )
      result = decodeURIComponent(result);
    return result;
  }

  /**
   * @description The runCSSMedia() method indicates that the current document is running under the "@media only screen and (max-width: 580px)" CSS rule
   * @retruns {boolean} Returns true if the current document is running under the "@media only screen and (max-width: 580px)" CSS rule
   * @since 1.7
  */
  function runCSSMedia()
  {
    var oRTOC = document.getElementById(R);  // {object} holds a reference to `R` part of the document
    return getComputedStyle(oRTOC).position != "absolute";
  }
  
  /**
   * @description The fitTOC() method fits the `TOC` and `CNT` elements (Table of Contents and Content) to the window
   * @param {object} toc Specifies the `TOC` element to resize/fit
   * @param {object} cnt Specifies the `CNT` element to resize/fit
   */
  function fitTOC(toc, cnt)
  {
    if (!runCSSMedia())
    {
      toc = toc || document.getElementById(TOC);       // {object} Specifies the `TOC` element
      cnt = cnt || document.getElementById(CNT);       // {object} Specifies the `CNT` element

      var border = 8,                                       // {number} indicates the border-size
          rtClientTOC = toc && toc.getBoundingClientRect(), // {object} gets a DOMRect object providing information about the size of `TOC` element and its position relative to the viewport.
          rtClientCNT = cnt && cnt.getBoundingClientRect(); // {object} gets a DOMRect object providing information about the size of `CNT` element and its position relative to the viewport.

      // sets the `TOC`'s height 
      toc && (toc.style.height = (window.innerHeight - (rtClientTOC.top + border)) + PX);
      
      // sets the `CNT`'s width and height
      if ( cnt )
      {
        cnt.style.height = (window.innerHeight - (rtClientCNT.top + border)) + PX;
        cnt.style.width = window.innerWidth - (rtClientTOC.width + border) + PX;
      }
    }
    // updates the height of the owner's frame to fits the entire body inside the <iframe> element
    rszIFrm();
  }

  /**
   * @description The rszIFrm() method updates the height of the owner's frame to fits the entire body inside the <iframe> element
  */
  function rszIFrm()
  {
    /**
     * @description The getHeight() method determines the height of the target
     * @param {HTMLElement} target A HTMLElement object whose height is requested
     * @returns {number} Returns the height of the element/target
    */
    function getHeight(target)
    {
      return target && (target instanceof HTMLCanvasElement ? target.height : parseInt(oWindowR.getComputedStyle(target).height) || target.clientHeight) || 0;
    }

    var oWindowR = wR(),              // {object} specifies the window's root
        oFrame = window.frameElement; // {object} returns the element (such as <iframe> or <object>) in which the window is embedded.

    if ( oFrame )
    {
      oFrame.height = oWindowR.innerHeight - (8 + getHeight(oWindowR.document.getElementById("cssmenu")));
      oWindowR.document.body.style.overflowY = "hidden";
    }
  }

  /**
   * @description The rszLR/resizeLeftRight() method resizes the `L` and `R` parts of the mainframe
   * @param {object} event Indicates the event that initialize the resize
  */
  function rszLR(event)
  {
    /**
     * @description The getStyle() method gets the style of the element
     * @param {HTMLElement} element A HTMLElement object to request its style
     * @returns {object} Returns an live object (of CSSStyleDeclaration type) containing the values of all CSS properties of an element, after applying active stylesheets and resolving any basic computation those values may contain.
    */
    function getStyle(element)
    {
      return window.getComputedStyle(element);
    }

    /**
     * @description The resizeBy() method resizes the `L`/`R` parts by specified ammont
     * @param {number} dx Indicates the offset to resize by
    */
    function resizeBy(dx)
    {
      // resizes the `L`/`R` parts by specified ammont
      oLTOC.style.width = oRTOC.style.left = Math.max(6, Math.min(parseInt(getStyle(oRTOC).width) - 8, original.w + dx)) + PX;

      // fits the `TOC` and `CNT` elements (Table of Contents and Content) to the window
      fitTOC();
    }

    /**
     * @description The onMoveResizeWidth() handler is associated with the window's mousemove event resize the width
     * @param {MouseEvent} event A MouseEvent that occured
    */
    function onmove(event)
    {
      // prevents any default-action
      preventDefault(event);
      
      // resizes the width of all target-elements
      resizeBy(event.screenX - original.x);
    }

    /**
     * @description The onup() handler is associated with the window's mouseup event.
    */
    function onup()
    {
        // restores the CNT's pointerEvents
        if ( cnt )
          cnt.style.pointerEvents = cntPointerEvents;
    
      window.removeEventListener("mousemove", onmove);
      window.removeEventListener("mouseup", onup);
    }

    if ( !runCSSMedia() )
    {
      var oLTOC = document.getElementById(L),  // {object} holds a reference to `L` part of the document
          oRTOC = document.getElementById(R),  // {object} holds a reference to `R` part of the document
          cnt = document.getElementById(CNT),  // {object} indicates the `CNT` element
          original =                                // {object} holds initial position of the `L`/`R` parts of the document
          {
            x: event.screenX,                       // {number} provides the horizontal coordinate (offset) of the mouse pointer in global (screen) coordinates.
            w: parseInt(getStyle(oLTOC).width)      // {number} specifies the initial-width of the `L` part of the document
          },
          cntPointerEvents;                         // {string} holds the value of CNT's pointerEvents property

      if ( oLTOC && oRTOC )
      {
        // *Fixed: The resizing of the navbar section of the frame pauses when the cursor hovers over the content area (right panel)
        if ( cnt )
        {
          cntPointerEvents = cnt.style.pointerEvents;
          cnt.style.pointerEvents = "none"; // !!! prevents mouse-events over the 'CNT' iframe, else the resizing stops while cursor hovers the IFRAME element
        }

        // sets the mousemove/mouseup event handlers to resize the width/height of the rgTargets by drag and drop
        window.addEventListener("mousemove", onmove );
        window.addEventListener("mouseup", onup );
      }
    }
  }

  /**
   * @description The setSource() method changes the `CNT`'s source and updates the browser's URL
   * @param {string} source Specifies the URL to browse for
  */
  function setSource(source)
  {
    /**
     * @description The getSParam() method extracts the source-parameter
     * @param {string} source A string expression that defines the source
    */
    function getSParam(source)
    {
      var nSrcPathRel = source.lastIndexOf('/');
      return ~nSrcPathRel ? source.substr(nSrcPathRel + 1) : source
    }

    /**
     * @description The setActive() method activates the LI element which contains the source and ensures that the LI element fits the `TOC` element
     * @param {string} source Indicates the URL to activate
    */
    function setActive(source)
    {
      /**
       * @description The hrefOf() method gets the "href" attribute of any child <a> element
       * @param {object} oElement Specifies the element to search <a> element for
       * @returns {string} Returns the "href" attribute of the element
      */
      function hrefOf(oElement)
      {
        return feU(oElement.getElementsByTagName(A), function(oElement)
        {
          return oElement.getAttribute("href");
        });
      }

      /**
       * @description The defaultOf() method determines the source's default name
       * @param {string} source Specifies the source to get default for
       * @returns {string} Returns the source's default name such as "Chart_default.htm" for "Chart_AllowCreateBar.htm"
      */
      function defaultOf(source)
      {
        var underline = source.lastIndexOf('_'),
            dot;
        if ( ~underline )
          source = source.substr(0, underline + 1) + "default" + (~(dot = source.indexOf('.',underline)) ? source.substr(dot) : "" );
        return source;
      }

      /**
       * @description The LIOf() method gets the "LI" element that hosts the source (includes an element whose "href" attribute is equivalent with the source)
       * @param {string} source Indicates the URL to search for
      */
      function LIOf(source)
      {
        return feU(rgLI, function(oLI)
        {
          return (hrefOf(oLI) == source) && oLI;
        })
      }

      var toc = document.getElementById(TOC); // {object} indicates the `TOC` element

      if ( toc )
      {
        var rgLI = toc.getElementsByTagName("LI"),  // {object} gets the "LI" elements of the `TOC` element
            sActiveClass = ACTIVE,             // {string} specifies the name of the class to highlight the active-source
            oActiveLI;                              // {object} indicates the "LI" element to activate

        // removes the "active" class from any previously "LI" elements
        feU(toc.getElementsByClassName(sActiveClass), function(oElement)
        {
          oElement.classList.remove(sActiveClass);
        })

        // sets the active "LI" based on the source (could be the source or source_default.htm)
        oActiveLI = LIOf(source) || LIOf(defaultOf(source));

        // activates the LI that's currently browsed
        if (oActiveLI) 
        {
          // adds "active" to source being selected
          oActiveLI.classList.add(sActiveClass);

          // ensures that the giving element fits the view's client area (scroll into the view)
          expEnsureVisible(oActiveLI);
        }
      }
    }

    if ( source != null ) // !!! prevents empty or null source (for instance, <a> element without a href attribute, such as bookmarks of "<a name=`bookmark`>" type)
    {
      if ( ~source.indexOf("://") ) // specifies a different protocol, changes the browser's URL instead (http://, https://, ...)
        wR().location = source;
      else
      {
        var cnt = document.getElementById(CNT);  // {object} indicates the `CNT` element
        if ( cnt )
        {
  /*    
          var sPathRel = "/Exontrol/ExG2antt/help2/web/",   // {string} specifies the relative-path
              nInsPathRel;                                  // {number} indicates the position of the last '/' character

          if ( sPathRel && (source.indexOf(sPathRel) < 0) )
          {
            nInsPathRel = source.lastIndexOf('/');
            if ( ~nInsPathRel )
            {
              nInsPathRel++;
              source = source.substr(0, nInsPathRel) + sPathRel + source.substr(nInsPathRel);
            }
            else
              source = sPathRel + source;
          }
  //*/
          if ( cnt.getAttribute("src") != source ) // prevents re-loading the same page if the user clicks it several times
          {
            // sets the `CNT`'s source
            cnt.src = source;

            // extracts the `S` param from source (for instance, "web/information.htm" => "information.htm")
            source = getSParam(source);

            // activates the LI element which contains the source and ensures that the LI element fits the `TOC` element
            setActive(source);

            // updates the `S` param of the browser's URL
            setP(PARAM.S, source);
          }
        }
      }
    }
  }

  /**
   * @description The tO/toggleObject() method toggles the expand/collapse state of the object (adds or removes the `expanded` class)
   * @param {object} oObjectLI Indicates an object of `object` class 
   */
  function tO(oObjectLI)
  {
    var oCL;  // {object} indicates an object of DOMTokenList type that holds classes of the element

    if ( oObjectLI && (oCL = oObjectLI.classList).contains(OBJECT) )
      oCL[updateclassList(oCL.contains(EXPANDED))].call(oCL, EXPANDED);
  }

  /**
   * @description cC/clickClose() method performs actions once the user clicks the `close` button of the `Filter` element
  */
  function cC()
  {
    var filter = document.getElementById(FILTER);  // {object} inidcates the input-element that displays the current filter (`Filter` element)
    if ( filter )
    {
      filter.value = "";
      filter.oninput();
    }
  }

  /**
   * @description The cntHighlightFilter() method highlights the filter in the content-document (highlights matches and filters literals into the InfoTable)
   * @param {HTMLDocument} document Specifies the document the filter is applying to (CNT)
   * @param {string} filter Indicates the filter to apply
   * @param {boolean} [noScrollIntoView] Specifies a boolean expression to prevent scrolling the first match into the view
  */
  function cntHighlightFilter(document, filter, noScrollIntoView)
  {
    /**
     * @description The highlightFilterOccurrences() method highlights all occurrences of the filter in visible text nodes by wrapping matches in a <span> element with the FILTERMATCH class.
     * @param {RegExp} oRegEx Specifies the regular expression used to find filter matches
     * @param {number} nIndex Specifies the index of the current filter term
    */
    function highlightFilterOccurrences(oRegEx, nIndex)
    {
      var oWalker = document.createTreeWalker(oBody, NodeFilter.SHOW_TEXT),
          rgNodes = [];

      // collects the text-nodes
      while (oWalker.nextNode())
          rgNodes.push(oWalker.currentNode);

      // enumerates each text-node, search for the filter and replace with '<span class="`${FILTERMATCH}`">match</span>'
      rgNodes.forEach(function(oNode)
      {
        var oParent = oNode.parentNode,
            sText = oNode.nodeValue,
            oFragmentDoc = document.createDocumentFragment(), 
            nLastIndex = 0;

        sText.replace(oRegEx, function(sMatch, nOffset)
        {
          nOffset > nLastIndex && oFragmentDoc.appendChild(document.createTextNode(sText.slice(nLastIndex, nOffset)));

            var span = document.createElement("span");
              span.className = FILTERMATCH + " F" + (nIndex + 1); // adds also F1, F2, ... classes to differentiate between multiple filter terms
              span.textContent = sMatch;
            oFragmentDoc.appendChild(span);
          
          nLastIndex = nOffset + sMatch.length;
        });

        nLastIndex < sText.length && oFragmentDoc.appendChild(document.createTextNode(sText.slice(nLastIndex)));

        oParent.replaceChild(oFragmentDoc, oNode);
      });
    }

    /**
     * @description The unHighlightFilterOccurrences() method removes all <span> elements added by highlightFilterOccurrences(), restores original text, and merges adjacent text nodes to maintain natural text continuity.
    */
    function unHighlightFilterOccurrences()
    {
      // replaces each FilterMatch <span> with a text node containing the span’s text content
      oBody.querySelectorAll('.' + FILTERMATCH).forEach(function(oSpan)
      {
        oSpan.replaceWith(document.createTextNode(oSpan.textContent));
      });

      var oWalker = document.createTreeWalker(oBody, NodeFilter.SHOW_ELEMENT), // NodeFilter.SHOW_ELEMENT(1), shows only element nodes (<div>, <p>, <span>, etc.)
          rgParents = [];

      // collects all nodes of the DOM
      while (oWalker.nextNode())
        rgParents.push(oWalker.currentNode);

      // merges adjacent text nodes to restore the original continuous text after previous operations created multiple separate text nodes
      rgParents.forEach(function(oParent)
      {
        for (var oChild = oParent.firstChild, oNext; oChild; )
          if ((oNext = oChild.nextSibling) && oChild.nodeType == 3 && oNext.nodeType == 3) /*Node.TEXT_NODE(3), a text node containing plain text*/
          {
            oChild.nodeValue += oNext.nodeValue;
            oParent.removeChild(oNext);
          }
          else
            oChild = oNext;
      });
    }

    /**
     * @description The setExcludeRows() method iterates over the InfoTable rows and assigns the FilterMatchExclude class to rows that do not match the filter
    */
    function setExcludeRows()
    {
      feU(oBody.querySelectorAll("." + INFOTABLE), function(oTable)
      {
        // checks if the table lists the literals, as a table of Name, Value and Description type
        if ( oTable.rows.length > 1 )
          if ( NAMEVALUEDESC == oTable.rows[0].innerText.trim() )
            for ( var i = 1, l = oTable.rows.length, oRow; (i < l) && (oRow = oTable.rows[i]); i++ )
              if ( !oFilter.match(oRow.innerText) )
                oRow.classList.add(FILTERMATCHEXCLUDE);
      })
    }

    /**
     * @description The resetHighlight() method removes all highlight and inclusion/exclusion effects by restoring original text and clearing applied classes
     * @param {callback} [onfinish] Specifies the callback to invoke once the animation ends
    */
    function resetHighlight(onfinish)
    {
      // smoothly includes the rows that match the filter
      animateExcludeRows(true /*visible*/, onfinish);

      // removes the FilterMatchExclude class, making all rows visible
      feU(oBody.querySelectorAll("." + FILTERMATCHEXCLUDE), function(oRow)
      {
        oRow.classList.remove(FILTERMATCHEXCLUDE);
      });

      // removes all highlighted words by replacing FilterMatch <span> elements with their original text
      unHighlightFilterOccurrences();
    }

    /**
     * @description The findVisibleOf() method finds the first element of the specified class that is fully visible in the viewport
     * @param {string} className Specifies the class name to search for
     * @returns {Element|null} Returns the first fully visible element, or null if none is visible
    */
    function findVisibleOf(className)
    {
      return feU(document.querySelectorAll('.' + className), function(oElement)
      {
        var rtElement = oElement.getBoundingClientRect();
        return rtElement.top >= 0 && rtElement.bottom <= window.innerHeight && oElement;
      }) || null;
    }

    /**
     * @description The animateExcludeRows() method smoothly includes or excludes rows containing the filtered symbols.
     * @param {boolean} visible Indicates whether the method should show or hide the rows
     * @param {callback} [onfinish] Specifies the callback to invoke once the animation ends
    */
    function animateExcludeRows(visible, onfinish)
    {
      var lonfinish; // {number} represents the setTimeout handle used to trigger the onfinish callback
      feU(oBody.querySelectorAll("." + FILTERMATCHEXCLUDE), function(oRow)
      {
        // makes the row visible to measure heights
        if ( visible )
          oRow.style.display = "table-row";

        // wraps the cell's content in a single custom 'wrap' element, enabling its height to be smoothly animated from 0 to the measured value and back
        feU(oRow.children, function(td)
        {
          // ensures that the 'td' element includes a single 'wrap' custom-element
          var oWrap = td.firstElementChild;
          if (!oWrap || oWrap.tagName != WRAP)
          {
            oWrap = document.createElement(WRAP);
              while (td.firstChild)
                oWrap.appendChild(td.firstChild);
            td.appendChild(oWrap);
          }

          // animates height from 0 -> measured height if visible or reversed if hidden
          oWrap.animate(
            [
              { height: (visible ? 0 : oWrap.offsetHeight) + PX}, // from
              { height: (visible ? oWrap.offsetHeight : 0) + PX } // to
            ],
            {
              duration,
              easing
            }
          ).onfinish = function()
          {
            if ( !visible )
              oRow.style.display = "none";
            oWrap.style.height = '';

            // invokes the callback only after the animation for all rows has finished
            if ( onfinish )
            {
              clearTimeout(lonfinish)
              lonfinish = setTimeout(function()
              {
                onfinish();
              })
            }
          };
        })
      });
    }  

    nCntCounter++;
    try
    {
      var oBody = document.body,        // {HTMLBodyElement} specifies the document's body (CNT's body)
          oFilter = getFilter(filter),  // {object} indicates the filter object, with values to filter for, that includes the match(value) {boolean} method to verify whether an item matches the filter
          o1stHighlight2Fit;            // {HTMLElement} specifies the HTML element to be refitted into view when the user clears the filter

      // stores the first FILTERMATCH element currently in view so it can be brought back into view when the document is restored
      if ( !filter )
        if ( o1stHighlight2Fit = findVisibleOf(FILTERMATCH) )
          o1stHighlight2Fit = o1stHighlight2Fit.parentElement;

      // clears all previously applied highlights and, after the animation completes, ensures the parent of the first visible highlighted match fits into the viewport when the filter is cleared
      resetHighlight( !noScrollIntoView && !filter && ensureVisible(o1stHighlight2Fit) ); // ensures the parent of the first highlighted match is visible when the filter is cleared

      // applies highlighting to the new matches
      if ( filter )
      {
        // iterates over the InfoTable rows and assigns the FilterMatchExclude class to rows that do not match the filter
        setExcludeRows();

        // highlights the occurences of the filter
        oFilter.terms.forEach(function(oTerm, index)
        {
          highlightFilterOccurrences(oTerm, index);
        })
        // ensures the first highlighted match is visible in the viewport
        !noScrollIntoView && ensureVisible(document.querySelector('.' + FILTERMATCH));

        // smoothly excludes the rows that match the filter
        animateExcludeRows(false /*visible*/);
      }
    }
    catch(e)
    {
      //Uncaught TypeError: Cannot read properties of null (reading 'body')
    }
  }

  /**
   * @description The load event is fired when the whole page has loaded, including all dependent resources such as stylesheets and images.
  */
  window.addEventListener("load", function(/*event*/)
  {
    /**
     * @description The initTOC() method initializes the `TOC` element (handles the click event of each <a> element to redirect the content to `CNT` element)
    */
    function initTOC()
    {
      /**
       * @description The onClickAnhor() method opens the anchor's reference into the `CNT` element
       * @param {object} event Indicates the event that generates the click event
      */
      function onClickAnhor(event)
      {
        // prevents any default action 
        preventDefault(event);

        // changes the `CNT`'s source and updates the browser's URL
        setSource(this.getAttribute("href"))
      }

      // replaces the A's click handler for all A-elements of the `TOC` element
      feU(toc.getElementsByTagName(A), function(oAnchor)
      {
        oAnchor.onclick = onClickAnhor;
      });
    }

    /**
     * @description The initFilter() method initializes the `Filter` element, so it filters for LI elements of the `TOC`
    */
    function initFilter()
    {
      /**
       * @description The onFilter() method is called once the filter is changed to show/hide the LI elements of the `TOC` element
       * @param {string} value Specifies the filter (if null/undefined/empty the filter is removed)
       * @param {object} event Indicates the event that invoked the onFilter method (called during filter.oninput method)
      */
      function onFilter(value, event)
      {
        /**
         * @description The match() method checks whether the item matches the value (filter)
         * @param {object} oLI Indicates an "LI" element to verify it it matches the value (filter)
         * @returns {boolean} Returns true if the item matches the value (filter)
        */
        function match(oLI)
        {
          /**
           * @description The textContent() method gets the content of the node and its descendants, to match the filter
           * @param {object} oElement Indicates the element to gets its text
           * @returns {string} Returns the the content of the node and its descendants, to match the filter
          */
          function textContent(oElement, bFirstLineOnly)
          {
            var result = oElement.className,  // {string} specifies "object", "event", "constant", ...
                oAnchorLI;                    // {object} indicates the <a> inside of LI element
      
            // includes the "property", "method" and "readonly" for "object" LI elements
            if ( oElement.classList.contains(OBJECT) )
              result = OBJECT + EOL + PROPERTY + EOL + METHOD;

            // *Added: Include the "title" (description) and "data-values" (values of an enumeration type) attributes of the <a> inside of LI element, while filtering. Currently, the filter includes the property, method, event or type's name, description and values (for enumeration types) (enum type includes each defined constants such as <a href="CheckStateEnum_enum.htm" data-values="Unchecked(0),Checked(1),PartialChecked(2)">CheckStateEnum</a>)
            if ( oAnchorLI = oElement.firstChild )
            {
              if ( oAnchorLI.title )
                result += EOL + oAnchorLI.title;  // includes the "title" attribute

              if ( oAnchorLI.dataset && oAnchorLI.dataset.values )
                result += EOL + oAnchorLI.dataset.values; // includes "data-values" attribute
            }

            // includes the text content of the node and its descendants.
            return result + EOL + (bFirstLineOnly ? oElement.textContent.trim().split(EOL)[0] || "" : oElement.textContent.trim());
          }

          /**
           * @description The itemContent() method represents the text content of the node and its descendants, to match the filter
           * @param {object} oLI Indicates an "LI" element to get its text to filter for
           * @returns {string} Returns the text content of the node and its descendants
          */
          function itemContent(oLI)
          {
            var result = textContent(oLI),  // {string} indicates the item's text to match
                oParentLI;                  // {string} indicates the item's text to match

            if ( oLI.parentElement && (oParentLI = oLI.parentElement.parentElement) && (oParentLI.tagName == "LI") )
              result += EOL + textContent(oParentLI, true /*bFirstLineOnly*/);

            return result;
          }
    
          return oFilter.match(itemContent(oLI));
        }

        var bExpandAll = !value,        // {boolean} specifies whether all "LI" objects should be expanded
            oFilter = getFilter(value), // {object} indicates the filter object, with values to filter for, that includes the match(value) {boolean} method to verify whether an item matches the filter
            nTopics = 0,                // {number} specifies the number of "topic" elements
            nHiddenTopics = 0,          // {number} specifies the number of "topic" elements being hidden
            oActiveLI,                  // {object} indicates the active "LI" element
            bHidden,                    // {boolean} indicates whether the object is hidden
            oCL;                        // {object} indicates an object of DOMTokenList type that holds classes of the element

        // adds or removes the `hidden` class to LI elements of `TOC` that does not match filter
        feU(toc.getElementsByTagName("LI"), function(oLI)
        {
          (oCL = oLI.classList)[updateclassList(match(oLI))].call(oCL, HIDDEN);
        });

        // adds or removes the `hidden` class to "object"/LI elements of `TOC` that dislays no properties/methods
        feU(toc.getElementsByClassName(OBJECT), function(oObjectLI)
        {
          oCL = oObjectLI.classList;
          bHidden = oObjectLI.getElementsByClassName(HIDDEN).length == oObjectLI.getElementsByTagName("LI").length;
          oCL[updateclassList(!bHidden)].call(oCL, HIDDEN);
          !bHidden && oCL[updateclassList(bExpandAll)].call(oCL, EXPANDED);
        })

        // adds or removes the `hidden` class to "topic"/DIV elements of `TOC` that does not match filter
        feU(toc.getElementsByClassName(TOPIC), function(oTopicDiv)
        {
          nTopics++;
          bHidden = oTopicDiv.getElementsByTagName("LI").length == oTopicDiv.getElementsByClassName(HIDDEN).length;
            (oCL = oTopicDiv.classList)[updateclassList(!bHidden)].call(oCL, HIDDEN);
          bHidden && nHiddenTopics++;
        });

        // adds or removes the `hidden` class to `TOC` itself, when no match
        nTopics && (oCL = toc.classList)[updateclassList(nTopics != nHiddenTopics)].call(oCL, HIDDEN);

        // expands or collapses the "LI" elements
        feU(toc.getElementsByClassName(OBJECT), function(oLI)
        {
          (oCL = oLI.classList)[updateclassList(bExpandAll)].call(oCL, EXPANDED);
        })

        // updates the "filter" value
        !event && (filter.value = value);
        
        // adds or removes the `close` class to parent element of "filter" element
        (oCL = filter.parentElement.classList)[updateclassList(!filter.value)].call(oCL, CLOSE);

        // updates the browser's `F` param
        setP(PARAM.F, value || null /*removes if empty string*/);

        // ensures that the active "LI" element fits the scroll view
        (oActiveLI = toc.getElementsByClassName("active").item(0)) && setTimeout(function()
        {
          expEnsureVisible(oActiveLI);
        })

        // delays updating the filter highlights in the content document while the user is typing
        clearTimeout(lCntFilter);
        lCntFilter = setTimeout(function()
        {
          cntHighlightFilter(cnt.contentDocument, filter.value);
        }, duration)
      }

      // adds the input `Filter` and span close elements to display the `Filter` field
      var divF = document.getElementById(F), // {object} indicates the DIV element that displays the `Filter`
          span;                                   // {object} specifies the SPAN to display `✖` character

      if ( divF )
      {
        // creates and adds the input `Filter` field
        filter = document.createElement("INPUT");
          filter.setAttribute("type", "text");
          filter.setAttribute("id", "Filter");
          filter.setAttribute("placeHolder", "Filter for...");
          filter.oninput = function(event)  // The oninput attribute fires when the value of an <input> or <textarea> element is changed.
          {
            clearTimeout(lFilterTimeout);
            lFilterTimeout = setTimeout(function()
            {
              onFilter(event && event.target.value || "");
            }, event ? 512 : 0);
          }
        document.getElementById(F).appendChild(filter);

        // adds the SPAN `✖` character
        span = document.createElement("SPAN");
          span.id = CLOSE;              // specifies the "id=`close`"
          span.innerHTML = "&#x2716;";  // displays the `✖` character
        document.getElementById(F).appendChild(span);
      }

      // updates the filter according with the browser's `F` param
      filter && onFilter(getP(PARAM.F));
    }

    /**
     * @description The initCNT() method initalizes the `CNT` element
    */
    function initCNT()
    {
      if ( cnt )
      {
        // changes the `CNT`'s source and updates the browser's URL
        setSource(getP(PARAM.S) || cnt.getAttribute("src"));

        // syncronizes the current hash with the CNT's hash
        syncH(cnt);

        // The load event is fired when the whole page has loaded, including all dependent resources such as stylesheets and images
        cnt.onload = function(event)
        {
          /**
           * @description The onCNTAnchorClick() method re-directs clicking the anchor-elements of the iframe to the `CNT`'s source
           * @param {object} event Indicates the event (MouseEvent)
          */
          function onCNTAnchorClick(event)
          {
            var hRef = this.getAttribute("href"); // {string} gets the href attribute of the anchor element, such as "https://exontrol.com/exgrid.jsp", "Appearance_Add.htm" "#constants"
            if ( hRef && !hRef.startsWith("#")) // !!! prevents navigation when clicking on an internal bookmark link
            {
              // prevents the event's default-actions
              preventDefault(event);

              // changes the `CNT`'s source and updates the browser's URL
              setSource(hRef);
            }
          }

          // replaces the <a>'s onclick handler to change the `CNT`'s source and update the browser's URL
          if (this.contentDocument) 
          {
            var source = getP(PARAM.S)  // {string} indicates the current source of the `CNT` element
            feU(this.contentDocument.getElementsByTagName(A), function(oAnchor)
            {
              // disables the anchor that points to the current source
              oAnchor.getAttribute("href") == source && oAnchor.classList.add(DISABLED);

              // sets the onclick handler to re-direct clicking the anchor-elements of the iframe to the `CNT`'s source
              oAnchor.onclick = onCNTAnchorClick;
            });

            // *Added: Toggles the filter highlighting in the main content on Escape key (for accessibility) events, to quickly show/hide the filter highlights in the content-document (@since 26.02)
            var toggleCbk = (function(event)
            {
              (!event.key || event.key == "Escape") && 
                cntHighlightFilter(this.contentDocument, this.contentDocument.querySelector('.' + FILTERMATCHEXCLUDE) ? "" : filter.value, true /*noScrollIntoView*/);
            }.bind(this));
            this.contentWindow.addEventListener("keydown", toggleCbk);

            // updates the document's title according with the title of the source being loaded
            wR().document.title = this.contentDocument.title;

            // highlights the filter in the content-document
            nCntCounter && // ignores the first call because cntHighlightFilter is automatically invoked during the onFilter method, preventing flickering on initial load
              cntHighlightFilter(this.contentDocument, filter.value);
          }
        }
      }
    }

    var toc = document.getElementById(TOC), // {object} Specifies the `TOC` element
        cnt = document.getElementById(CNT), // {object} Specifies the `CNT` element
        oLTOC = document.getElementById(L), // {object} holds a reference to `L` part of the document
        lFilterTimeout,                     // {number} represents the setTimeout handle used to delay filtering while the user is typing
        filter;                             // {object} specifies the INPUT to display `Filter` field

    // initializes the `TOC`, `Filter` and `CNT` elements
    if ( toc )
    {
      initTOC();
      initFilter();
    }
    cnt && initCNT();
    fitTOC(toc, cnt);

    // sets the version CSS variable
    oLTOC && oLTOC.style.setProperty('--version', '"' + VERSION + '"');
  });

  /**
   * @description The resize event fires when the document view (window) has been resized
  */
  window.addEventListener("resize", function(/*event*/)
  {
    fitTOC();
  });

  /**
   * @description The hashchange event is fired when the fragment identifier of the URL has changed (the part of the URL beginning with and following the # symbol).
   */
  wR().addEventListener("hashchange", function(event)
  {
    syncH();
  });

  /**
   * @description The mousemove event is fired at an element when a pointing device (usually a mouse) is moved while the cursor's hotspot is inside it.
  */
  window.addEventListener("mousemove", function(event)
  {
    if ( !runCSSMedia() )
    {
      // updates the `L`-element's cursor to "col-resize", while the pointer hovers the right-side of the `L`-element
      var oLTOC = document.getElementById(L); // {object} holds a reference to `L` part of the document
      if (oLTOC)
        oLTOC.style.cursor = isVerticalSplit(event) ? "col-resize" : "";
    }
  })

  /**
   * @description The mousedown event is fired at an Element when a pointing device button is pressed while the pointer is inside the element.
  */
  window.addEventListener("mousedown", function(event)
  {
    var o,        // {object} indicates the object being checked
        oCL,      // {object} indicates an object of DOMTokenList type that holds classes of the element
        oToggle;  // {object} indicates an element to toggles its expand/collapse state

    // expands or collapses the "LI" object once the user clicks the "LI" object, `glyph` or the anchor element of the "LI" object
    if ( ((o = event.target) && (oCL = o.classList).contains(OBJECT) && (oToggle = o)) ||
        ((o = event.target) && (oCL = o.classList).contains(GLYPH) && (oToggle = o.parentElement)) ||
        ((o = event.target) && (o = o.parentElement) && (o = o.parentElement) && (oCL = o.classList).contains(OBJECT) && !oCL.contains(EXPANDED) && (oToggle = o)) )
      oToggle && tO(oToggle);
    else
      if ( isVerticalSplit(event) ) // clicks the right-side of the `L`-element, to resize `L` and `R` parts of the mainframe
        rszLR(event);
      else
        if ( event.target.id == CLOSE ) // clicks the `close` portion of the `Filter` input
          cC();
  });

})));

//# sourceURL=> names the script for the debugger and allows you to set breakpoints in it, even if it was created dynamically
//# sourceURL=file:///E:/Exontrol/JS-Help/help.js