/*
    * Copyright (c) 2002-2026 Gargoyle Software Inc.
    *
    * Licensed under the Apache License, Version 2.0 (the "License");
    * you may not use this file except in compliance with the License.
    * You may obtain a copy of the License at
    * https://www.apache.org/licenses/LICENSE-2.0
    *
    * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   */
  package org.htmlunit.html;
  
  import static org.htmlunit.BrowserVersionFeatures.EVENT_FOCUS_ON_LOAD;
  import static org.htmlunit.BrowserVersionFeatures.HTTP_HEADER_CH_UA;
  import static org.htmlunit.html.DomElement.ATTRIBUTE_NOT_DEFINED;
  
  import java.io.File;
  import java.io.IOException;
  import java.io.ObjectInputStream;
  import java.io.ObjectOutputStream;
  import java.io.Serializable;
  import java.net.MalformedURLException;
  import java.net.URL;
  import java.nio.charset.Charset;
  import java.nio.charset.StandardCharsets;
  import java.util.ArrayList;
  import java.util.Arrays;
  import java.util.Collection;
  import java.util.Collections;
  import java.util.Comparator;
  import java.util.HashMap;
  import java.util.HashSet;
  import java.util.Iterator;
  import java.util.LinkedHashSet;
  import java.util.List;
  import java.util.Locale;
  import java.util.Map;
  import java.util.Set;
  import java.util.WeakHashMap;
  import java.util.concurrent.ConcurrentHashMap;
  
  import javax.xml.XMLConstants;
  
  import org.apache.commons.lang3.StringUtils;
  import org.apache.commons.logging.Log;
  import org.apache.commons.logging.LogFactory;
  import org.htmlunit.Cache;
  import org.htmlunit.ElementNotFoundException;
  import org.htmlunit.FailingHttpStatusCodeException;
  import org.htmlunit.History;
  import org.htmlunit.HttpHeader;
  import org.htmlunit.OnbeforeunloadHandler;
  import org.htmlunit.Page;
  import org.htmlunit.ScriptResult;
  import org.htmlunit.SgmlPage;
  import org.htmlunit.TopLevelWindow;
  import org.htmlunit.WebAssert;
  import org.htmlunit.WebClient;
  import org.htmlunit.WebClientOptions;
  import org.htmlunit.WebRequest;
  import org.htmlunit.WebResponse;
  import org.htmlunit.WebWindow;
  import org.htmlunit.corejs.javascript.Function;
  import org.htmlunit.corejs.javascript.Script;
  import org.htmlunit.corejs.javascript.Scriptable;
  import org.htmlunit.corejs.javascript.ScriptableObject;
  import org.htmlunit.corejs.javascript.VarScope;
  import org.htmlunit.css.ComputedCssStyleDeclaration;
  import org.htmlunit.css.CssStyleSheet;
  import org.htmlunit.html.impl.SimpleRange;
  import org.htmlunit.html.parser.HTMLParserDOMBuilder;
  import org.htmlunit.http.HttpStatus;
  import org.htmlunit.javascript.AbstractJavaScriptEngine;
  import org.htmlunit.javascript.HtmlUnitScriptable;
  import org.htmlunit.javascript.JavaScriptEngine;
  import org.htmlunit.javascript.PostponedAction;
  import org.htmlunit.javascript.host.Window;
  import org.htmlunit.javascript.host.event.BeforeUnloadEvent;
  import org.htmlunit.javascript.host.event.Event;
  import org.htmlunit.javascript.host.event.EventTarget;
  import org.htmlunit.javascript.host.html.HTMLDocument;
  import org.htmlunit.protocol.javascript.JavaScriptURLConnection;
  import org.htmlunit.util.MimeType;
  import org.htmlunit.util.SerializableLock;
  import org.htmlunit.util.UrlUtils;
  import org.w3c.dom.Attr;
  import org.w3c.dom.Comment;
  import org.w3c.dom.DOMConfiguration;
  import org.w3c.dom.DOMException;
  import org.w3c.dom.DOMImplementation;
  import org.w3c.dom.Document;
  import org.w3c.dom.DocumentType;
  import org.w3c.dom.Element;
  import org.w3c.dom.EntityReference;
  import org.w3c.dom.ProcessingInstruction;
 
 /**
  * A representation of an HTML page returned from a server.
  * <p>
  * This class provides different methods to access the page's content like
  * {@link #getForms()}, {@link #getAnchors()}, {@link #getElementById(String)}, ... as well as the
  * very powerful inherited methods {@link #getByXPath(String)} and {@link #getFirstByXPath(String)}
  * for fine grained user specific access to child nodes.
  * </p>
  * <p>
  * Child elements allowing user interaction provide methods for this purpose like {@link HtmlAnchor#click()},
  * {@link HtmlInput#type(String)}, {@link HtmlOption#setSelected(boolean)}, ...
  * </p>
  * <p>
  * HtmlPage instances should not be instantiated directly. They will be returned by {@link WebClient#getPage(String)}
  * when the content type of the server's response is <code>text/html</code> (or one of its variations).<br>
  * <br>
  * <b>Example:</b><br>
  * <br>
  * <code>
  * final HtmlPage page = webClient.{@link WebClient#getPage(String) getPage}("http://mywebsite/some/page.html");
  * </code>
  * </p>
  *
  * @author Mike Bowler
  * @author Alex Nikiforoff
  * @author Noboru Sinohara
  * @author David K. Taylor
  * @author Andreas Hangler
  * @author Christian Sell
  * @author Chris Erskine
  * @author Marc Guillemot
  * @author Ahmed Ashour
  * @author Daniel Gredler
  * @author Dmitri Zoubkov
  * @author Sudhan Moghe
  * @author Ethan Glasser-Camp
  * @author Tom Anderson
  * @author Ronald Brill
  * @author Frank Danek
  * @author Joerg Werner
  * @author Atsushi Nakagawa
  * @author Rural Hunter
  * @author Ronny Shapiro
  * @author Lai Quang Duong
  * @author Sven Strickroth
  * @author Vidya m
  */
 @SuppressWarnings("PMD.TooManyFields")
 public class HtmlPage extends SgmlPage {
 
     private static final Log LOG = LogFactory.getLog(HtmlPage.class);
 
     private static final Comparator<DomElement> DOCUMENT_POSITION_COMPERATOR = new DocumentPositionComparator();
 
     private HTMLParserDOMBuilder domBuilder_;
     private transient Charset originalCharset_;
     private final Object lock_ = new SerializableLock(); // used for synchronization
 
     private Map<String, MappedElementIndexEntry> idMap_ = new ConcurrentHashMap<>();
     private Map<String, MappedElementIndexEntry> nameMap_ = new ConcurrentHashMap<>();
     // The id/name lookup index is built lazily on first use. Until then,
     // notifyNodeAdded / fireAttributeChange skip the per-element index updates.
     // Reads must call ensureMappedElementsBuilt() before consulting idMap_/nameMap_.
     private boolean mappedElementsBuilt_;
 
     private List<BaseFrameElement> frameElements_ = new ArrayList<>();
     private int parserCount_;
     private int snippetParserCount_;
     private int inlineSnippetParserCount_;
     private Collection<HtmlAttributeChangeListener> attributeListeners_;
     private List<PostponedAction> afterLoadActions_ = Collections.synchronizedList(new ArrayList<>());
     private boolean cleaning_;
     private HtmlBase base_;
     private URL baseUrl_;
     private List<AutoCloseable> autoCloseableList_;
     private ElementFromPointHandler elementFromPointHandler_;
     private DomElement elementWithFocus_;
     private List<SimpleRange> selectionRanges_ = new ArrayList<>(3);
 
     private transient ComputedStylesCache computedStylesCache_;
 
     private static final HashSet<String> TABBABLE_TAGS =
             new HashSet<>(Arrays.asList(HtmlAnchor.TAG_NAME, HtmlArea.TAG_NAME,
                     HtmlButton.TAG_NAME, HtmlInput.TAG_NAME, HtmlObject.TAG_NAME,
                     HtmlSelect.TAG_NAME, HtmlTextArea.TAG_NAME));
     private static final HashSet<String> ACCEPTABLE_TAG_NAMES =
             new HashSet<>(Arrays.asList(HtmlAnchor.TAG_NAME, HtmlArea.TAG_NAME,
                     HtmlButton.TAG_NAME, HtmlInput.TAG_NAME, HtmlLabel.TAG_NAME,
                     HtmlLegend.TAG_NAME, HtmlTextArea.TAG_NAME));
 
     /** Definition of special cases for the smart DomHtmlAttributeChangeListenerImpl. */
     private static final Set<String> ATTRIBUTES_AFFECTING_PARENT = new HashSet<>(Arrays.asList(
             "style",
             "class",
             "height",
             "width"));
 
     static class DocumentPositionComparator implements Comparator<DomElement>, Serializable {
         @Override
         public int compare(final DomElement elt1, final DomElement elt2) {
             final short relation = elt1.compareDocumentPosition(elt2);
             if (relation == 0) {
                 return 0; // same node
             }
             if ((relation & DOCUMENT_POSITION_CONTAINS) != 0 || (relation & DOCUMENT_POSITION_PRECEDING) != 0) {
                 return 1;
             }
 
             return -1;
         }
     }
 
     /**
      * Creates an instance of HtmlPage.
      * An HtmlPage instance is normally retrieved with {@link WebClient#getPage(String)}.
      *
      * @param webResponse the web response that was used to create this page
      * @param webWindow the window that this page is being loaded into
      */
     public HtmlPage(final WebResponse webResponse, final WebWindow webWindow) {
         super(webResponse, webWindow);
     }
 
     /**
      * {@inheritDoc}
      */
     @Override
     public HtmlPage getPage() {
         return this;
     }
 
     /**
      * {@inheritDoc}
      */
     @Override
     public boolean hasCaseSensitiveTagNames() {
         return false;
     }
 
     /**
      * Initialize this page.
      * @throws IOException if an IO problem occurs
      * @throws FailingHttpStatusCodeException if the server returns a failing status code AND the property
      *         {@link org.htmlunit.WebClientOptions#setThrowExceptionOnFailingStatusCode(boolean)} is set
      *         to true.
      */
     @Override
     public void initialize() throws IOException, FailingHttpStatusCodeException {
         final WebWindow enclosingWindow = getEnclosingWindow();
         final boolean isAboutBlank = getUrl() == UrlUtils.URL_ABOUT_BLANK;
         if (isAboutBlank) {
             // a frame contains first a faked "about:blank" before its real content specified by src gets loaded
             if (enclosingWindow instanceof FrameWindow window
                     && !window.getFrameElement().isContentLoaded()) {
                 return;
             }
 
             // save the URL that should be used to resolve relative URLs in this page
             if (enclosingWindow instanceof TopLevelWindow topWindow) {
                 final WebWindow openerWindow = topWindow.getOpener();
                 if (openerWindow != null && openerWindow.getEnclosedPage() != null) {
                     baseUrl_ = openerWindow.getEnclosedPage().getWebResponse().getWebRequest().getUrl();
                 }
             }
         }
 
         if (!isAboutBlank) {
             setReadyState(READY_STATE_INTERACTIVE);
             getDocumentElement().setReadyState(READY_STATE_INTERACTIVE);
             executeEventHandlersIfNeeded(Event.TYPE_READY_STATE_CHANGE);
         }
 
         executeDeferredScriptsIfNeeded();
 
         executeEventHandlersIfNeeded(Event.TYPE_DOM_DOCUMENT_LOADED);
 
         // postponed actions are more or less the async scripts,
         // they are running in real browsers whenever the download is done
         processPostponedActionsIfNeeded();
 
         loadFrames();
 
         // don't set the ready state if we really load the blank page into the window
         // see Node.initInlineFrameIfNeeded()
         if (!isAboutBlank) {
             setReadyState(READY_STATE_COMPLETE);
             getDocumentElement().setReadyState(READY_STATE_COMPLETE);
             executeEventHandlersIfNeeded(Event.TYPE_READY_STATE_CHANGE);
         }
 
         // frame initialization has a different order
         boolean isFrameWindow = enclosingWindow instanceof FrameWindow;
         boolean isFirstPageInFrameWindow = false;
         if (isFrameWindow) {
             isFrameWindow = ((FrameWindow) enclosingWindow).getFrameElement() instanceof HtmlFrame;
 
             final History hist = enclosingWindow.getHistory();
             if (hist.getLength() > 0 && UrlUtils.URL_ABOUT_BLANK == hist.getUrl(0)) {
                 isFirstPageInFrameWindow = hist.getLength() <= 2;
             }
             else {
                 isFirstPageInFrameWindow = enclosingWindow.getHistory().getLength() < 2;
             }
         }
 
         if (isFrameWindow && !isFirstPageInFrameWindow) {
             executeEventHandlersIfNeeded(Event.TYPE_LOAD);
         }
 
         for (final BaseFrameElement frameElement : new ArrayList<>(frameElements_)) {
             if (frameElement instanceof HtmlFrame) {
                 final Page page = frameElement.getEnclosedWindow().getEnclosedPage();
                 if (page != null && page.isHtmlPage()) {
                     ((HtmlPage) page).executeEventHandlersIfNeeded(Event.TYPE_LOAD);
                 }
             }
         }
 
         if (!isFrameWindow) {
             executeEventHandlersIfNeeded(Event.TYPE_LOAD);
 
             if (!isAboutBlank && enclosingWindow.getWebClient().isJavaScriptEnabled()
                     && hasFeature(EVENT_FOCUS_ON_LOAD)) {
                 final HtmlElement body = getBody();
                 if (body != null) {
                     final Event event = new Event((Window) enclosingWindow.getScriptableObject(), Event.TYPE_FOCUS);
                     body.fireEvent(event);
                 }
             }
         }
 
         try {
             while (!afterLoadActions_.isEmpty()) {
                 final PostponedAction action = afterLoadActions_.remove(0);
                 action.execute();
             }
         }
         catch (final IOException e) {
             throw e;
         }
         catch (final Exception e) {
             throw new RuntimeException(e);
         }
         executeRefreshIfNeeded();
     }
 
     /**
      * Adds an action that should be executed once the page has been loaded.
      * @param action the action
      */
     void addAfterLoadAction(final PostponedAction action) {
         afterLoadActions_.add(action);
     }
 
     /**
      * Clean up this page.
      */
     @Override
     public void cleanUp() {
         //To avoid endless recursion caused by window.close() in onUnload
         if (cleaning_) {
             return;
         }
 
         cleaning_ = true;
         try {
             super.cleanUp();
             executeEventHandlersIfNeeded(Event.TYPE_UNLOAD);
             deregisterFramesIfNeeded();
         }
         finally {
             cleaning_ = false;
 
             if (autoCloseableList_ != null) {
                 for (final AutoCloseable closeable : new ArrayList<>(autoCloseableList_)) {
                     try {
                         closeable.close();
                     }
                     catch (final Exception e) {
                         LOG.error("Closing the autoclosable " + closeable + " failed", e);
                     }
                 }
             }
         }
     }
 
     /**
      * {@inheritDoc}
      */
     @Override
     public HtmlElement getDocumentElement() {
         return (HtmlElement) super.getDocumentElement();
     }
 
     /**
      * Returns the document's {@code body} element.
      *
      * @return the document's {@code body} element, or {@code null} if it does
      *         not exist
      */
     public HtmlBody getBody() {
         final DomElement doc = getDocumentElement();
         if (doc != null) {
             for (final DomNode node : doc.getChildren()) {
                 if (node instanceof HtmlBody body) {
                     return body;
                 }
             }
         }
         return null;
     }
 
     /**
      * Returns the head element.
      * @return the head element
      */
     public HtmlElement getHead() {
         final DomElement doc = getDocumentElement();
         if (doc != null) {
             for (final DomNode node : doc.getChildren()) {
                 if (node instanceof HtmlHead) {
                     return (HtmlElement) node;
                 }
             }
         }
         return null;
     }
 
     /**
      * {@inheritDoc}
      */
     @Override
     public Document getOwnerDocument() {
         return null;
     }
 
     /**
      * {@inheritDoc}
      * Not yet implemented.
      */
     @Override
     public org.w3c.dom.Node importNode(final org.w3c.dom.Node importedNode, final boolean deep) {
         throw new UnsupportedOperationException("HtmlPage.importNode is not yet implemented.");
     }
 
     /**
      * {@inheritDoc}
      * Not yet implemented.
      */
     @Override
     public String getInputEncoding() {
         throw new UnsupportedOperationException("HtmlPage.getInputEncoding is not yet implemented.");
     }
 
     /**
      * {@inheritDoc}
      */
     @Override
     public String getXmlEncoding() {
         return null;
     }
 
     /**
      * {@inheritDoc}
      */
     @Override
     public boolean getXmlStandalone() {
         return false;
     }
 
     /**
      * {@inheritDoc}
      * Not yet implemented.
      */
     @Override
     public void setXmlStandalone(final boolean xmlStandalone) throws DOMException {
         throw new UnsupportedOperationException("HtmlPage.setXmlStandalone is not yet implemented.");
     }
 
     /**
      * {@inheritDoc}
      */
     @Override
     public String getXmlVersion() {
         return null;
     }
 
     /**
      * {@inheritDoc}
      * Not yet implemented.
      */
     @Override
     public void setXmlVersion(final String xmlVersion) throws DOMException {
         throw new UnsupportedOperationException("HtmlPage.setXmlVersion is not yet implemented.");
     }
 
     /**
      * {@inheritDoc}
      * Not yet implemented.
      */
     @Override
     public boolean getStrictErrorChecking() {
         throw new UnsupportedOperationException("HtmlPage.getStrictErrorChecking is not yet implemented.");
     }
 
     /**
      * {@inheritDoc}
      * Not yet implemented.
      */
     @Override
     public void setStrictErrorChecking(final boolean strictErrorChecking) {
         throw new UnsupportedOperationException("HtmlPage.setStrictErrorChecking is not yet implemented.");
     }
 
     /**
      * {@inheritDoc}
      * Not yet implemented.
      */
     @Override
     public String getDocumentURI() {
         throw new UnsupportedOperationException("HtmlPage.getDocumentURI is not yet implemented.");
     }
 
     /**
      * {@inheritDoc}
      * Not yet implemented.
      */
     @Override
     public void setDocumentURI(final String documentURI) {
         throw new UnsupportedOperationException("HtmlPage.setDocumentURI is not yet implemented.");
     }
 
     /**
      * {@inheritDoc}
      * Not yet implemented.
      */
     @Override
     public org.w3c.dom.Node adoptNode(final org.w3c.dom.Node source) throws DOMException {
         throw new UnsupportedOperationException("HtmlPage.adoptNode is not yet implemented.");
     }
 
     /**
      * {@inheritDoc}
      * Not yet implemented.
      */
     @Override
     public DOMConfiguration getDomConfig() {
         throw new UnsupportedOperationException("HtmlPage.getDomConfig is not yet implemented.");
     }
 
     /**
      * {@inheritDoc}
      * Not yet implemented.
      */
     @Override
     public org.w3c.dom.Node renameNode(final org.w3c.dom.Node newNode, final String namespaceURI,
         final String qualifiedName) throws DOMException {
         throw new UnsupportedOperationException("HtmlPage.renameNode is not yet implemented.");
     }
 
     /**
      * {@inheritDoc}
      */
     @Override
     public Charset getCharset() {
         if (originalCharset_ == null) {
             originalCharset_ = getWebResponse().getContentCharset();
         }
         return originalCharset_;
     }
 
     /**
      * {@inheritDoc}
      */
     @Override
     public String getContentType() {
         return getWebResponse().getContentType();
     }
 
     /**
      * {@inheritDoc}
      * Not yet implemented.
      */
     @Override
     public DOMImplementation getImplementation() {
         throw new UnsupportedOperationException("HtmlPage.getImplementation is not yet implemented.");
     }
 
     /**
      * {@inheritDoc}
      * @param tagName the tag name, preferably in lowercase
      */
     @Override
     public DomElement createElement(String tagName) {
         if (tagName.indexOf(':') == -1) {
             tagName = org.htmlunit.util.StringUtils.toRootLowerCase(tagName);
         }
         return getWebClient().getPageCreator().getHtmlParser().getFactory(tagName)
                     .createElementNS(this, null, tagName, null);
     }
 
     /**
      * {@inheritDoc}
      */
     @Override
     public DomElement createElementNS(final String namespaceURI, final String qualifiedName) {
         return getWebClient().getPageCreator().getHtmlParser()
                 .getElementFactory(this, namespaceURI, qualifiedName, false, true)
                 .createElementNS(this, namespaceURI, qualifiedName, null);
     }
 
     /**
      * {@inheritDoc}
      * <p>Unlike {@link #createAttribute(String)} the name is not lower cased.</p>
      */
     @Override
     public DomAttr createAttributeNS(final String namespaceURI, final String qualifiedName) {
         // an empty namespace is the same as no namespace
         final String namespace = org.htmlunit.util.StringUtils.isEmptyOrNull(namespaceURI) ? null : namespaceURI;
 
         final int colonPosition = qualifiedName.indexOf(':');
         final String prefix = colonPosition == -1 ? null : qualifiedName.substring(0, colonPosition);
         final boolean xmlns = XMLConstants.XMLNS_ATTRIBUTE.equals(prefix)
                 || XMLConstants.XMLNS_ATTRIBUTE.equals(qualifiedName);
 
         if ((prefix != null && namespace == null)
                 || (XMLConstants.XML_NS_PREFIX.equals(prefix) && !XMLConstants.XML_NS_URI.equals(namespace))
                 || (xmlns && !XMLConstants.XMLNS_ATTRIBUTE_NS_URI.equals(namespace))
                 || (!xmlns && XMLConstants.XMLNS_ATTRIBUTE_NS_URI.equals(namespace))) {
             throw new DOMException(DOMException.NAMESPACE_ERR,
                     "createAttributeNS: invalid namespace '" + namespaceURI + "' for '" + qualifiedName + "'");
         }
 
         return new DomAttr(this, namespace, qualifiedName, "", false);
     }
 
     /**
      * {@inheritDoc}
      * <p>Entity references are not supported by HTML documents (DOM Level 2 Core). They are removed
      * from the DOM standard and the browsers do not offer {@code createEntityReference}.
      * </p>
      */
     @Override
     public EntityReference createEntityReference(final String name) {
         throw new DOMException(DOMException.NOT_SUPPORTED_ERR,
                 "HtmlPage.createEntityReference: entity references are not supported by HTML documents.");
     }
 
     /**
      * {@inheritDoc}
      * <p>DOM Level 2 Core forbids processing instructions in HTML documents, but the DOM standard and the
      * browsers allow them and {@code document.createProcessingInstruction()} relies on this.
      * </p>
      */
     @Override
     public DomProcessingInstruction createProcessingInstruction(final String target, final String data) {
         return new DomProcessingInstruction(this, target, data);
     }
 
     /**
      * {@inheritDoc}
      */
     @Override
     public DomElement getElementById(final String elementId) {
         if (elementId != null) {
             ensureMappedElementsBuilt();
             final MappedElementIndexEntry elements = idMap_.get(elementId);
             if (elements != null) {
                 return elements.first();
             }
         }
         return null;
     }
 
     /**
      * Returns the {@link HtmlAnchor} with the specified name.
      *
      * @param name the name to search by
      * @return the {@link HtmlAnchor} with the specified name
      * @throws ElementNotFoundException if the anchor could not be found
      */
     public HtmlAnchor getAnchorByName(final String name) throws ElementNotFoundException {
         return getDocumentElement().getOneHtmlElementByAttribute("a", DomElement.NAME_ATTRIBUTE, name);
     }
 
     /**
      * Returns the {@link HtmlAnchor} with the specified href.
      *
      * @param href the string to search by
      * @return the HtmlAnchor
      * @throws ElementNotFoundException if the anchor could not be found
      */
     public HtmlAnchor getAnchorByHref(final String href) throws ElementNotFoundException {
         return getDocumentElement().getOneHtmlElementByAttribute("a", "href", href);
     }
 
     /**
      * Returns a list of all anchors contained in this page.
      * @return the list of {@link HtmlAnchor} in this page
      */
     public List<HtmlAnchor> getAnchors() {
         return getDocumentElement().getElementsByTagNameImpl("a");
     }
 
     /**
      * Returns the first anchor with the specified text.
      * @param text the text to search for
      * @return the first anchor that was found
      * @throws ElementNotFoundException if no anchors are found with the specified text
      */
     public HtmlAnchor getAnchorByText(final String text) throws ElementNotFoundException {
         WebAssert.notNull("text", text);
 
         for (final HtmlAnchor anchor : getAnchors()) {
             if (text.equals(anchor.asNormalizedText())) {
                 return anchor;
             }
         }
         throw new ElementNotFoundException("a", "<text>", text);
     }
 
     /**
      * Returns the first form that matches the specified name.
      * @param name the name to search for
      * @return the first form
      * @throws ElementNotFoundException If no forms match the specified result.
      */
     public HtmlForm getFormByName(final String name) throws ElementNotFoundException {
         final List<HtmlForm> forms = getDocumentElement()
                 .getElementsByAttribute("form", DomElement.NAME_ATTRIBUTE, name);
         if (forms.isEmpty()) {
             throw new ElementNotFoundException("form", DomElement.NAME_ATTRIBUTE, name);
         }
         return forms.get(0);
     }
 
     /**
      * Returns a list of all the forms in this page.
      * @return all the forms in this page
      */
     public List<HtmlForm> getForms() {
         return getDocumentElement().getElementsByTagNameImpl("form");
     }
 
     /**
      * Given a relative URL (ie <code>/foo</code>), returns a fully-qualified URL based on
      * the URL that was used to load this page.
      *
      * @param relativeUrl the relative URL
      * @return the fully-qualified URL for the specified relative URL
      * @throws MalformedURLException if an error occurred when creating a URL object
      */
     public URL getFullyQualifiedUrl(String relativeUrl) throws MalformedURLException {
         // to handle http: and http:/ in FF (Bug #474)
         boolean incorrectnessNotified = false;
         while (relativeUrl.startsWith("http:") && !relativeUrl.startsWith("http://")) {
             if (!incorrectnessNotified) {
                 notifyIncorrectness("Incorrect URL \"" + relativeUrl + "\" has been corrected");
                 incorrectnessNotified = true;
             }
             relativeUrl = "http:/" + relativeUrl.substring(5);
         }
 
         return WebClient.expandUrl(getBaseURL(), relativeUrl);
     }
 
     /**
      * Given a target attribute value, resolve the target using a base target for the page.
      *
      * @param elementTarget the target specified as an attribute of the element
      * @return the resolved target to use for the element
      */
     public String getResolvedTarget(final String elementTarget) {
         final String resolvedTarget;
         if (base_ == null) {
             resolvedTarget = elementTarget;
         }
         else if (elementTarget != null && !elementTarget.isEmpty()) {
             resolvedTarget = elementTarget;
         }
         else {
             resolvedTarget = base_.getTargetAttribute();
         }
         return resolvedTarget;
     }
 
     /**
      * Returns a list of ids (strings) that correspond to the tabbable elements
      * in this page. Return them in the same order specified in {@link #getTabbableElements}
      *
      * @return the list of id's
      */
     public List<String> getTabbableElementIds() {
         final List<String> list = new ArrayList<>();
 
         for (final HtmlElement element : getTabbableElements()) {
             list.add(element.getId());
         }
 
         return Collections.unmodifiableList(list);
     }
 
     /**
      * Returns a list of all elements that are tabbable in the order that will
      * be used for tabbing.
      * <p>
      * The rules for determining tab order are as follows:
      * </p>
      * <ol>
      *   <li>Those elements that support the tabindex attribute and assign a
      *   positive value to it are navigated first. Navigation proceeds from the
      *   element with the lowest tabindex value to the element with the highest
      *   value. Values need not be sequential nor must they begin with any
      *   particular value. Elements that have identical tabindex values should
      *   be navigated in the order they appear in the character stream.</li>
      *   <li>Those elements that do not support the tabindex attribute or
      *   support it and assign it a value of "0" are navigated next. These
      *   elements are navigated in the order they appear in the character
      *   stream.</li>
      *   <li>Elements that are disabled do not participate in the tabbing
      *   order.</li>
      * </ol>
      * <p>
      * Additionally, the value of tabindex must be within 0 and 32767. Any
      * values outside this range will be ignored.
      * </p>
      * <p>
      * The following elements support the <code>tabindex</code> attribute:
      * A, AREA, BUTTON, INPUT, OBJECT, SELECT, and TEXTAREA.
      * </p>
      *
      * @return all the tabbable elements in proper tab order
      */
     public List<HtmlElement> getTabbableElements() {
         final List<HtmlElement> tabbableElements = new ArrayList<>();
         for (final HtmlElement element : getHtmlElementDescendants()) {
             final String tagName = element.getTagName();
             if (TABBABLE_TAGS.contains(tagName)) {
                 final boolean disabled = element.isDisabledElementAndDisabled();
                 if (!disabled && !HtmlElement.TAB_INDEX_OUT_OF_BOUNDS.equals(element.getTabIndex())) {
                     tabbableElements.add(element);
                 }
             }
         }
         tabbableElements.sort(createTabOrderComparator());
         return Collections.unmodifiableList(tabbableElements);
     }
 
     private static Comparator<HtmlElement> createTabOrderComparator() {
         return (element1, element2) -> {
             final Short i1 = element1.getTabIndex();
             final Short i2 = element2.getTabIndex();
 
             final short index1;
             if (i1 == null) {
                 index1 = -1;
             }
             else {
                 index1 = i1.shortValue();
             }
 
             final short index2;
             if (i2 == null) {
                 index2 = -1;
             }
             else {
                 index2 = i2.shortValue();
             }
 
             final int result;
             if (index1 > 0 && index2 > 0) {
                 result = index1 - index2;
             }
             else if (index1 > 0) {
                 result = -1;
             }
             else if (index2 > 0) {
                 result = 1;
             }
             else if (index1 == index2) {
                 result = 0;
             }
             else {
                 result = index2 - index1;
             }
 
             return result;
         };
     }
 
     /**
      * Returns the HTML element that is assigned to the specified access key. An
      * access key (aka mnemonic key) is used for keyboard navigation of the
      * page.
      * <p>
      * Only the following HTML elements may have <code>accesskey</code>s defined: A, AREA,
      * BUTTON, INPUT, LABEL, LEGEND, and TEXTAREA.
      * </p>
      *
      * @param accessKey the key to look for
      * @return the HTML element that is assigned to the specified key or null
      *      if no elements can be found that match the specified key.
      */
     public HtmlElement getHtmlElementByAccessKey(final char accessKey) {
         final List<HtmlElement> elements = getHtmlElementsByAccessKey(accessKey);
         if (elements.isEmpty()) {
             return null;
         }
         return elements.get(0);
     }
 
     /**
      * Returns all the HTML elements that are assigned to the specified access key. An
      * access key (aka mnemonic key) is used for keyboard navigation of the
      * page.
      * <p>
      * The HTML specification seems to indicate that one accesskey cannot be used
      * for multiple elements however Internet Explorer does seem to support this.
      * It's worth noting that Firefox does not support multiple elements with one
      * access key so you are making your HTML browser specific if you rely on this
      * feature.
      * </p>
      *
      * <p>
      * Only the following HTML elements may have <code>accesskey</code>s defined: A, AREA,
      * BUTTON, INPUT, LABEL, LEGEND, and TEXTAREA.
      * </p>
      *
      * @param accessKey the key to look for
      * @return the elements that are assigned to the specified accesskey
      */
     public List<HtmlElement> getHtmlElementsByAccessKey(final char accessKey) {
         final List<HtmlElement> elements = new ArrayList<>();
 
         final String searchString = Character.toString(accessKey).toLowerCase(Locale.ROOT);
         for (final HtmlElement element : getHtmlElementDescendants()) {
             if (ACCEPTABLE_TAG_NAMES.contains(element.getTagName())) {
                 final String accessKeyAttribute = element.getAttributeDirect("accesskey");
                 if (searchString.equalsIgnoreCase(accessKeyAttribute)) {
                     elements.add(element);
                 }
             }
         }
 
         return elements;
     }
 
     /**
      * <p>Executes the specified JavaScript code within the page. The usage would be similar to what can
      * be achieved to execute JavaScript in the current page by entering "javascript:...some JS code..."
      * in the URL field of a native browser.</p>
      * <p><b>Note:</b> the provided code won't be executed if JavaScript has been disabled on the WebClient
      * (see {@link org.htmlunit.WebClient#isJavaScriptEnabled()}).</p>
      * @param sourceCode the JavaScript code to execute
      * @return a ScriptResult which will contain both the current page (which may be different from
      *         the previous page) and a JavaScript result object
      */
     public ScriptResult executeJavaScript(final String sourceCode) {
         return executeJavaScript(sourceCode, "injected script", 1);
     }
 
     /**
      * <span style="color:red">INTERNAL API - SUBJECT TO CHANGE AT ANY TIME - USE AT YOUR OWN RISK.</span><br>
      * <p>
      * Execute the specified JavaScript if a JavaScript engine was successfully
      * instantiated. If this JavaScript causes the current page to be reloaded
      * (through location="" or form.submit()) then return the new page, otherwise
      * return the current page.
      * </p>
      * <p><b>Please note:</b> Although this method is public, it is not intended for
      * general execution of JavaScript. Users of HtmlUnit should interact with the pages
      * as a user would by clicking on buttons or links and having the JavaScript event
      * handlers execute as needed.
      * </p>
      *
      * @param sourceCode the JavaScript code to execute
      * @param sourceName the name for this chunk of code (will be displayed in error messages)
      * @param startLine the line at which the script source starts
      * @return a ScriptResult which will contain both the current page (which may be different from
      *         the previous page) and a JavaScript result object.
      */
     public ScriptResult executeJavaScript(String sourceCode, final String sourceName, final int startLine) {
         if (!getWebClient().isJavaScriptEnabled()) {
             return new ScriptResult(JavaScriptEngine.UNDEFINED);
         }
 
         if (org.htmlunit.util.StringUtils.startsWithIgnoreCase(sourceCode,
                                                 JavaScriptURLConnection.JAVASCRIPT_PREFIX)) {
             sourceCode = sourceCode.substring(JavaScriptURLConnection.JAVASCRIPT_PREFIX.length()).trim();
             if (sourceCode.startsWith("return ")) {
                 sourceCode = sourceCode.substring("return ".length());
             }
         }
 
         final Window window = getEnclosingWindow().getScriptableObject();
         final VarScope scope = ScriptableObject.getTopLevelScope(window.getParentScope());
 
         final Object result = getWebClient().getJavaScriptEngine()
                 .execute(this, scope, sourceCode, sourceName, startLine);
         return new ScriptResult(result);
     }
 
     /** Various possible external JavaScript file loading results. */
     enum JavaScriptLoadResult {
         /** The load was aborted and nothing was done. */
         NOOP,
         /** The load was aborted and nothing was done. */
         NO_CONTENT,
         /** The external JavaScript file was downloaded and compiled successfully. */
         SUCCESS,
         /** The external JavaScript file was not downloaded successfully. */
         DOWNLOAD_ERROR,
         /** The external JavaScript file was downloaded but was not compiled successfully. */
         COMPILATION_ERROR
     }
 
     /**
      * <span style="color:red">INTERNAL API - SUBJECT TO CHANGE AT ANY TIME - USE AT YOUR OWN RISK.</span><br>
      *
      * @param srcAttribute the source attribute from the script tag
      * @param scriptCharset the charset from the script tag
      * @return the result of loading the specified external JavaScript file
      * @throws FailingHttpStatusCodeException if the request's status code indicates a request
      *         failure and the {@link WebClient} was configured to throw exceptions on failing
      *         HTTP status codes
      */
     JavaScriptLoadResult loadExternalJavaScriptFile(final String srcAttribute,
                             final Charset scriptCharset, final boolean crossorigin)
         throws FailingHttpStatusCodeException {
 
         final WebClient client = getWebClient();
         if (org.htmlunit.util.StringUtils.isBlank(srcAttribute) || !client.isJavaScriptEnabled()) {
             return JavaScriptLoadResult.NOOP;
         }
 
         final URL scriptURL;
         try {
             scriptURL = getFullyQualifiedUrl(srcAttribute);
             final String protocol = scriptURL.getProtocol();
             if ("javascript".equals(protocol)) {
                 if (LOG.isInfoEnabled()) {
                     LOG.info("Ignoring script src [" + srcAttribute + "]");
                 }
                 return JavaScriptLoadResult.NOOP;
             }
             if (!"http".equals(protocol) && !"https".equals(protocol)
                     && !"data".equals(protocol) && !"file".equals(protocol)) {
                 client.getJavaScriptErrorListener().malformedScriptURL(this, srcAttribute,
                         new MalformedURLException("unknown protocol: '" + protocol + "'"));
                 return JavaScriptLoadResult.NOOP;
             }
         }
         catch (final MalformedURLException e) {
             client.getJavaScriptErrorListener().malformedScriptURL(this, srcAttribute, e);
             return JavaScriptLoadResult.NOOP;
         }
 
         final Object script;
         try {
             script = loadJavaScriptFromUrl(scriptURL, scriptCharset, crossorigin);
         }
         catch (final IOException e) {
             client.getJavaScriptErrorListener().loadScriptError(this, scriptURL, e);
             return JavaScriptLoadResult.DOWNLOAD_ERROR;
         }
         catch (final FailingHttpStatusCodeException e) {
             if (e.getStatusCode() == HttpStatus.NO_CONTENT_204) {
                 return JavaScriptLoadResult.NO_CONTENT;
             }
             client.getJavaScriptErrorListener().loadScriptError(this, scriptURL, e);
             throw e;
         }
 
         if (script == null) {
             return JavaScriptLoadResult.COMPILATION_ERROR;
         }
 
         final Window window = getEnclosingWindow().getScriptableObject();
         final VarScope scope = ScriptableObject.getTopLevelScope(window.getParentScope());
 
         @SuppressWarnings("unchecked")
         final AbstractJavaScriptEngine<Object> engine = (AbstractJavaScriptEngine<Object>) client.getJavaScriptEngine();
         engine.execute(this, scope, script);
         return JavaScriptLoadResult.SUCCESS;
     }
 
     /**
      * Loads JavaScript from the specified URL. This method may return {@code null} if
      * there is a problem loading the code from the specified URL.
      *
      * @param url the URL of the script
      * @param scriptCharset the charset from the script tag
      * @return the content of the file, or {@code null} if we ran into a compile error
      * @throws IOException if there is a problem downloading the JavaScript file
      * @throws FailingHttpStatusCodeException if the request's status code indicates a request
      *         failure and the {@link WebClient} was configured to throw exceptions on failing
      *         HTTP status codes
      */
     private Object loadJavaScriptFromUrl(final URL url, final Charset scriptCharset,
                     final boolean crossorigin) throws IOException,
         FailingHttpStatusCodeException {
 
         final WebRequest referringRequest = getWebResponse().getWebRequest();
 
         final WebClient client = getWebClient();
         final WebRequest request = new WebRequest(url);
         // copy all headers from the referring request
         request.setAdditionalHeaders(new HashMap<>(referringRequest.getAdditionalHeaders()));
         if (!UrlUtils.isSameOrigin(referringRequest.getUrl(), url)) {
             // credentials are not forwarded to another origin
             request.removeAdditionalHeader("Authorization");
         }
 
         // at least overwrite this headers
         request.setAdditionalHeader(HttpHeader.ACCEPT, client.getBrowserVersion().getScriptAcceptHeader());
 
         request.setFetchDestination(WebRequest.FetchDestination.SCRIPT);
         request.setRequestingUrl(referringRequest.getUrl());
         request.setFetchModeOverride(WebRequest.FetchMode.NO_CORS);
 
         request.setRefererHeader(referringRequest.getUrl());
         request.setCharset(scriptCharset);
 
         // use info from script tag or fall back to utf-8
         // https://www.rfc-editor.org/rfc/rfc9239#section-4.2
         if (scriptCharset != null) {
             request.setDefaultResponseContentCharset(scriptCharset);
         }
         else {
             request.setDefaultResponseContentCharset(StandardCharsets.UTF_8);
         }
 
         if (crossorigin) {
             request.setFetchModeOverride(WebRequest.FetchMode.CORS);
 
             if (client.getBrowserVersion().hasFeature(HTTP_HEADER_CH_UA)) {
                 request.setAdditionalHeader(HttpHeader.ORIGIN,
                         UrlUtils.getUrlWithProtocolAndAuthority(url).toExternalForm());
             }
         }
 
         // our cache is a bit strange;
         // loadWebResponse check the cache for the web response
         // AND also fixes the request url for the following cache lookups
         final WebResponse response = client.loadWebResponse(request);
 
         // now we can look into the cache with the fixed request for
         // a cached script
         final Cache cache = client.getCache();
         final Object cachedScript = cache.getCachedObject(request);
         if (cachedScript instanceof Script) {
             return cachedScript;
         }
 
         client.printContentIfNecessary(response);
         client.throwFailingHttpStatusCodeExceptionIfNecessary(response);
 
         final int statusCode = response.getStatusCode();
         if (statusCode == HttpStatus.NO_CONTENT_204) {
             throw new FailingHttpStatusCodeException(response);
         }
 
         if (!response.isSuccess()) {
             throw new IOException("Unable to download JavaScript from '" + url + "' (status " + statusCode + ").");
         }
 
         final String contentType = response.getContentType();
         if (contentType != null) {
             if (MimeType.isObsoleteJavascriptMimeType(contentType)) {
                 getWebClient().getIncorrectnessListener().notify(
                         "Obsolete content type encountered: '" + contentType + "' "
                                 + "for remotely loaded JavaScript element at '" + url + "'.", this);
             }
             else if (!MimeType.isJavascriptMimeType(contentType)) {
                 getWebClient().getIncorrectnessListener().notify(
                         "Expect content type of '" + MimeType.TEXT_JAVASCRIPT + "' "
                                 + "for remotely loaded JavaScript element at '" + url + "', "
                                 + "but got '" + contentType + "'.", this);
             }
         }
 
         final Charset scriptEncoding = response.getContentCharset();
         final String scriptCode = response.getContentAsString(scriptEncoding);
         if (null != scriptCode) {
             final AbstractJavaScriptEngine<?> javaScriptEngine = client.getJavaScriptEngine();
 
             final Window window = getEnclosingWindow().getScriptableObject();
             final VarScope scope = ScriptableObject.getTopLevelScope(window.getParentScope());
 
             final Object script = javaScriptEngine.compile(this, scope, scriptCode, url.toExternalForm(), 1);
             if (script != null && cache.cacheIfPossible(request, response, script)) {
                 // no cleanup if the response is stored inside the cache
                 return script;
             }
 
             response.cleanUp();
             return script;
         }
 
         response.cleanUp();
         return null;
     }
 
     /**
      * Returns the title like {@code document.title} does: the text of the first title element
      * with ASCII whitespace stripped and collapsed. Other spaces, including the non-breaking space, are kept.
      *
      * @return the title like {@code document.title}
      */
     public String getDocumentTitle() {
         final HtmlTitle title = getTitleElement();
         if (title == null) {
             return "";
         }
 
         final String titleTextContent = title.getText();
         final StringBuilder sb = new StringBuilder(titleTextContent.length());
         boolean pendingSpace = false;
         for (int i = 0; i < titleTextContent.length(); i++) {
             final char c = titleTextContent.charAt(i);
             if (c == ' ' || c == '\t' || c == '\n' || c == '\f' || c == '\r') {
                 pendingSpace = sb.length() > 0;
             }
             else {
                 if (pendingSpace) {
                     sb.append(' ');
                     pendingSpace = false;
                 }
                 sb.append(c);
             }
         }
         return sb.toString();
     }
 
     /**
      * Returns the normalized title of this page, or an empty string if no title element is present.
      * <p>
      * The returned text is normalized by collapsing consecutive whitespace characters
      * (including newlines and tabs) into a single space and trimming leading and trailing whitespace.
      * </p>
      *
      * @return the normalized page title, or an empty string if the title was not specified
      */
     public String getTitleText() {
         final HtmlTitle titleElement = getTitleElement();
         if (titleElement != null) {
             return titleElement.asNormalizedText();
         }
         return "";
     }
 
     /**
      * Sets the text for the title of this page. If there is not a title element
      * on this page, then one has to be generated.
      * @param message the new text
      */
     public void setTitleText(final String message) {
         HtmlTitle titleElement = getTitleElement();
         if (titleElement == null) {
             LOG.debug("No title element, creating one");
             final HtmlHead head = (HtmlHead) getFirstChildElement(getDocumentElement(), HtmlHead.class);
             if (head == null) {
                 // perhaps should we create head too?
                 throw new IllegalStateException("Headelement was not defined for this page");
             }
             final Map<String, DomAttr> emptyMap = Collections.emptyMap();
             titleElement = new HtmlTitle(HtmlTitle.TAG_NAME, this, emptyMap);
             if (head.getFirstChild() != null) {
                 head.getFirstChild().insertBefore(titleElement);
             }
             else {
                 head.appendChild(titleElement);
             }
         }
 
         titleElement.setText(message);
     }
 
     /**
      * Gets the first child of startElement that is an instance of the given class.
      * @param startElement the parent element
      * @param clazz the class to search for
      * @return {@code null} if no child found
      */
     private static DomElement getFirstChildElement(final DomElement startElement, final Class<?> clazz) {
         if (startElement == null) {
             return null;
         }
         for (final DomElement element : startElement.getChildElements()) {
             if (clazz.isInstance(element)) {
                 return element;
             }
         }
 
         return null;
     }
 
     /**
      * Gets the first child of startElement or it's children that is an instance of the given class.
      * @param startElement the parent element
      * @param clazz the class to search for
      * @return {@code null} if no child found
      */
     private DomElement getFirstChildElementRecursive(final DomElement startElement, final Class<?> clazz) {
         if (startElement == null) {
             return null;
         }
         for (final DomElement element : startElement.getChildElements()) {
             if (clazz.isInstance(element)) {
                 return element;
             }
             final DomElement childFound = getFirstChildElementRecursive(element, clazz);
             if (childFound != null) {
                 return childFound;
             }
         }
 
         return null;
     }
 
     /**
      * Gets the title element for this page. Returns null if one is not found.
      *
      * @return the title element for this page or null if this is not one
      */
     private HtmlTitle getTitleElement() {
         return (HtmlTitle) getFirstChildElementRecursive(getDocumentElement(), HtmlTitle.class);
     }
 
     /**
      * Looks for and executes any appropriate event handlers. Looks for body and frame tags.
      * @param eventType either {@link Event#TYPE_LOAD}, {@link Event#TYPE_UNLOAD}, or {@link Event#TYPE_BEFORE_UNLOAD}
      * @return {@code true} if user accepted <code>onbeforeunload</code> (not relevant to other events)
      */
     private boolean executeEventHandlersIfNeeded(final String eventType) {
         // If JavaScript isn't enabled, there's nothing for us to do.
         if (!getWebClient().isJavaScriptEnabled()) {
             return true;
         }
 
         // Execute the specified event on the document element.
         final WebWindow window = getEnclosingWindow();
         if (window.getScriptableObject() instanceof Window) {
             final Event event;
             if (Event.TYPE_BEFORE_UNLOAD.equals(eventType)) {
                 event = new BeforeUnloadEvent(this, eventType);
             }
             else {
                 event = new Event(this, eventType);
             }
 
             // This is the same as DomElement.fireEvent() and was copied
             // here so it could be used with HtmlPage.
             if (LOG.isDebugEnabled()) {
                 LOG.debug("Firing " + event);
             }
 
             final EventTarget jsNode;
             if (Event.TYPE_DOM_DOCUMENT_LOADED.equals(eventType)) {
                 jsNode = getScriptableObject();
             }
             else if (Event.TYPE_READY_STATE_CHANGE.equals(eventType)) {
                 jsNode = getDocumentElement().getScriptableObject();
             }
             else {
                 // The load/beforeunload/unload events target Document but paths Window only (tested in Chrome/FF)
                 jsNode = window.getScriptableObject();
             }
 
             ((JavaScriptEngine) getWebClient().getJavaScriptEngine()).callSecured(cx -> jsNode.fireEvent(event), this);
 
             if (!isOnbeforeunloadAccepted(this, event)) {
                 return false;
             }
         }
 
         // If this page was loaded in a frame, execute the version of the event specified on the frame tag.
         if (window instanceof FrameWindow fw) {
             final BaseFrameElement frame = fw.getFrameElement();
 
             // if part of a document fragment, then the load event is not triggered
             if (Event.TYPE_LOAD.equals(eventType) && frame.getParentNode() instanceof DomDocumentFragment) {
                 return true;
             }
 
             if (frame.hasEventHandlers("on" + eventType)) {
                 if (LOG.isDebugEnabled()) {
                     LOG.debug("Executing on" + eventType + " handler for " + frame);
                 }
                 if (window.getScriptableObject() instanceof Window) {
                     final Event event;
                     if (Event.TYPE_BEFORE_UNLOAD.equals(eventType)) {
                         event = new BeforeUnloadEvent(frame, eventType);
                     }
                     else {
                         event = new Event(frame, eventType);
                     }
                     // This fires the "load" event for the <frame> element which, like all non-window
                     // load events, propagates up to Document but not Window.  The "load" event for
                     // <frameset> on the other hand, like that of <body>, is handled above where it is
                     // fired against Document and directed to Window.
                     frame.fireEvent(event);
 
                     if (!isOnbeforeunloadAccepted((HtmlPage) frame.getPage(), event)) {
                         return false;
                     }
                 }
             }
         }
 
         return true;
     }
 
     /**
      * <span style="color:red">INTERNAL API - SUBJECT TO CHANGE AT ANY TIME - USE AT YOUR OWN RISK.</span><br>
      *
      * @return true if the OnbeforeunloadHandler has accepted to change the page
      */
     public boolean isOnbeforeunloadAccepted() {
         return executeEventHandlersIfNeeded(Event.TYPE_BEFORE_UNLOAD);
     }
 
     private boolean isOnbeforeunloadAccepted(final HtmlPage page, final Event event) {
         if (event instanceof BeforeUnloadEvent beforeUnloadEvent) {
             if (beforeUnloadEvent.isBeforeUnloadMessageSet()) {
                 final OnbeforeunloadHandler handler = getWebClient().getOnbeforeunloadHandler();
                 if (handler == null) {
                     LOG.warn("document.onbeforeunload() returned a string in event.returnValue,"
                             + " but no onbeforeunload handler installed.");
                 }
                 else {
                     final String message = JavaScriptEngine.toString(beforeUnloadEvent.getReturnValue());
                     return handler.handleEvent(page, message);
                 }
             }
         }
         return true;
     }
 
     /**
      * If a refresh has been specified either through a meta tag or an HTTP
      * response header, then perform that refresh.
      * @throws IOException if an IO problem occurs
      */
     private void executeRefreshIfNeeded() throws IOException {
         // If this page is not in a frame then a refresh has already happened,
         // most likely through the JavaScript onload handler, so we don't do a
         // second refresh.
         final WebWindow window = getEnclosingWindow();
         if (window == null) {
             return;
         }
 
         final String refreshString = getRefreshStringOrNull();
         if (refreshString == null || refreshString.isEmpty()) {
             return;
         }
 
         final double time;
         final URL url;
 
         final int index = StringUtils.indexOfAnyBut(refreshString, "0123456789.");
 
         if (index == -1) {
             // Format: <meta http-equiv='refresh' content='10'>
             try {
                 time = Double.parseDouble(refreshString);
             }
             catch (final NumberFormatException e) {
                 if (LOG.isErrorEnabled()) {
                     LOG.error("Malformed refresh string (no ';' but not a number): " + refreshString, e);
                 }
                 return;
             }
             url = getUrl();
         }
         else {
             // Format: <meta http-equiv='refresh' content='10;url=http://www.blah.com'>
             try {
                 time = Double.parseDouble(refreshString.substring(0, index));
             }
             catch (final NumberFormatException e) {
                 if (LOG.isErrorEnabled()) {
                     LOG.error("Malformed refresh string (no valid number before ';') " + refreshString, e);
                 }
                 return;
             }
 
             String urlPart = refreshString.substring(index);
             final char separator = urlPart.charAt(0);
             if (";, \r\n\t".indexOf(separator) >= 0) {
                 urlPart = StringUtils.stripStart(urlPart, ";, \r\n\t");
                 urlPart = urlPart.toLowerCase(Locale.ROOT);
                 if (urlPart.startsWith("url")) {
                     urlPart = urlPart.substring(3);
                     urlPart = urlPart.trim();
 
                     if (urlPart.length() > 0 && urlPart.charAt(0) == '=') {
                         urlPart = urlPart.substring(1);
                         urlPart = urlPart.trim();
                     }
                 }
 
                 if (org.htmlunit.util.StringUtils.isBlank(urlPart)) {
                     //content='10; URL=' is treated as content='10'
                     url = getUrl();
                 }
                 else {
                     if (urlPart.charAt(0) == '"' || urlPart.charAt(0) == 0x27) {
                         urlPart = urlPart.substring(1);
                     }
                     if (urlPart.charAt(urlPart.length() - 1) == '"' || urlPart.charAt(urlPart.length() - 1) == 0x27) {
                         urlPart = urlPart.substring(0, urlPart.length() - 1);
                     }
                     try {
                         url = getFullyQualifiedUrl(urlPart);
                     }
                     catch (final MalformedURLException e) {
                         if (LOG.isErrorEnabled()) {
                             LOG.error("Malformed URL in refresh string: " + refreshString, e);
                         }
                         return;
                     }
                 }
             }
             else {
                 if (LOG.isErrorEnabled()) {
                     LOG.error("Malformed refresh string (separator after time missing): " + refreshString);
                 }
                 return;
             }
         }
 
         processRefresh(url, time);
     }
 
     // this is different from what is done in org.htmlunit.WebClient.loadWebResponseFromWebConnection(WebRequest, int)
     // because there we are directly replacing the response before loading the response into the window
     // here we are replacing the page in the window (maybe after some time)
     private void processRefresh(final URL url, final double time) throws IOException {
         final WebClient webClient = getWebClient();
 
         final int refreshLimit = webClient.getOptions().getPageRefreshLimit();
         if (refreshLimit == 0) {
             final WebResponse webResponse = getWebResponse();
             throw new FailingHttpStatusCodeException("Too many redirects for "
                     + webResponse.getWebRequest().getUrl(), webResponse);
         }
 
         if (refreshLimit >= 0) {
             final StackTraceElement[] elements = new Exception().getStackTrace();
             int count = 0;
             final int elementCountLimit = refreshLimit > 50 ? 400 : refreshLimit > 10 ? 80 : 5;
             final int elementCount = elements.length;
 
             if (elementCount > elementCountLimit) {
                 for (int i = 0; i < elementCount; i++) {
                     if ("processRefresh".equals(elements[i].getMethodName())
                             && "org.htmlunit.html.HtmlPage".equals(elements[i].getClassName())) {
                         count++;
                         if (count >= refreshLimit) {
                             final WebResponse webResponse = getWebResponse();
                             throw new FailingHttpStatusCodeException(
                                             "Too many redirects (>= " + count + ") for "
                                                 + webResponse.getWebRequest().getUrl(), webResponse);
                         }
                     }
                 }
             }
         }
 
         webClient.getRefreshHandler().handleRefresh(this, url, (int) time);
     }
 
     /**
      * Returns an auto-refresh string if specified. This will look in both the meta
      * tags and inside the HTTP response headers.
      * @return the auto-refresh string
      */
     private String getRefreshStringOrNull() {
         final List<HtmlMeta> metaTags = getMetaTags("refresh");
         if (!metaTags.isEmpty()) {
             return metaTags.get(0).getContentAttribute().trim();
         }
         return getWebResponse().getResponseHeaderValue("Refresh");
     }
 
     private void processPostponedActionsIfNeeded() {
         if (!getWebClient().isJavaScriptEnabled()) {
             return;
         }
         getWebClient().getJavaScriptEngine().processPostponedActions();
     }
 
     /**
      * Executes any deferred scripts, if necessary.
      */
     private void executeDeferredScriptsIfNeeded() {
         if (!getWebClient().isJavaScriptEnabled()) {
             return;
         }
         final DomElement doc = getDocumentElement();
         final List<HtmlScript> scripts = new ArrayList<>();
 
         // don't call getElementsByTagName() here because it creates a live collection
         for (final HtmlElement elem : doc.getHtmlElementDescendants()) {
             if ("script".equals(elem.getLocalName()) && (elem instanceof HtmlScript script)) {
                 if (script.isDeferred() && ATTRIBUTE_NOT_DEFINED != script.getSrcAttribute()) {
                     scripts.add(script);
                 }
             }
         }
         for (final HtmlScript script : scripts) {
             ScriptElementSupport.executeScriptIfNeeded(script, true, true);
         }
     }
 
     /**
      * Deregister frames that are no longer in use.
      */
     public void deregisterFramesIfNeeded() {
         final List<BaseFrameElement> frameElementsCopy = new ArrayList<>(frameElements_);
         for (final BaseFrameElement frameElement : frameElementsCopy) {
             final WebWindow window = frameElement.getEnclosedWindow();
             getWebClient().deregisterWebWindow(window);
             final Page page = window.getEnclosedPage();
             if (page != null && page.isHtmlPage()) {
                 // seems quite silly, but for instance if the src attribute of an iframe is not
                 // set, the error only occurs when leaving the page
                 ((HtmlPage) page).deregisterFramesIfNeeded();
             }
         }
     }
 
     /**
      * Returns a list containing all the frames (from frame and iframe tags) in this page
      * in document order.
      * @return a list of {@link FrameWindow}
      */
     public List<FrameWindow> getFrames() {
         final List<BaseFrameElement> frameElements = new ArrayList<>(frameElements_);
         frameElements.sort(DOCUMENT_POSITION_COMPERATOR);
 
         final List<FrameWindow> list = new ArrayList<>(frameElements.size());
         for (final BaseFrameElement frameElement : frameElements) {
             list.add(frameElement.getEnclosedWindow());
         }
         return list;
     }
 
     /**
      * Returns the first frame contained in this page with the specified name.
      * @param name the name to search for
      * @return the first frame found
      * @throws ElementNotFoundException If no frame exist in this page with the specified name.
      */
     public FrameWindow getFrameByName(final String name) throws ElementNotFoundException {
         for (final BaseFrameElement frameElement : frameElements_) {
             final FrameWindow fw = frameElement.getEnclosedWindow();
             if (fw.getName().equals(name)) {
                 return fw;
             }
         }
 
         throw new ElementNotFoundException("frame or iframe", DomElement.NAME_ATTRIBUTE, name);
     }
 
     /**
      * Simulate pressing an access key. This may change the focus, may click buttons and may invoke
      * JavaScript.
      *
      * @param accessKey the key that will be pressed
      * @return the element that has the focus after pressing this access key or null if no element
      *         has the focus.
      * @throws IOException if an IO error occurs during the processing of this access key (this
      *         would only happen if the access key triggered a button which in turn caused a page load)
      */
     public DomElement pressAccessKey(final char accessKey) throws IOException {
         final HtmlElement element = getHtmlElementByAccessKey(accessKey);
         if (element != null) {
             element.focus();
             if (element instanceof HtmlAnchor
                     || element instanceof HtmlArea
                     || element instanceof HtmlButton
                     || element instanceof HtmlInput
                     || element instanceof HtmlLabel
                     || element instanceof HtmlLegend
                     || element instanceof HtmlTextArea) {
                 final Page newPage = element.click();
 
                 if (newPage != this && getFocusedElement() == element) {
                     // The page was reloaded therefore no element on this page will have the focus.
                     getFocusedElement().blur();
                 }
             }
         }
 
         return getFocusedElement();
     }
 
     /**
      * Move the focus to the next element in the tab order. To determine the specified tab
      * order, refer to {@link HtmlPage#getTabbableElements()}
      *
      * @return the element that has focus after calling this method
      */
     public HtmlElement tabToNextElement() {
         final List<HtmlElement> elements = getTabbableElements();
         if (elements.isEmpty()) {
             setFocusedElement(null);
             return null;
         }
 
         final HtmlElement elementToGiveFocus;
         final DomElement elementWithFocus = getFocusedElement();
         if (elementWithFocus == null) {
             elementToGiveFocus = elements.get(0);
         }
         else {
             final int index = elements.indexOf(elementWithFocus);
             if (index == -1) {
                 // The element with focus isn't on this page
                 elementToGiveFocus = elements.get(0);
             }
             else if (index == elements.size() - 1) {
                 // if at last jump to start
                 elementToGiveFocus = elements.get(0);
             }
             else {
                 elementToGiveFocus = elements.get(index + 1);
             }
         }
 
         setFocusedElement(elementToGiveFocus);
         return elementToGiveFocus;
     }
 
     /**
      * Move the focus to the previous element in the tab order. To determine the specified tab
      * order, refer to {@link HtmlPage#getTabbableElements()}
      *
      * @return the element that has focus after calling this method
      */
     public HtmlElement tabToPreviousElement() {
         final List<HtmlElement> elements = getTabbableElements();
         if (elements.isEmpty()) {
             setFocusedElement(null);
             return null;
         }
 
         final HtmlElement elementToGiveFocus;
         final DomElement elementWithFocus = getFocusedElement();
         if (elementWithFocus == null) {
             elementToGiveFocus = elements.get(elements.size() - 1);
         }
         else {
             final int index = elements.indexOf(elementWithFocus);
             if (index == -1) {
                 // The element with focus isn't on this page
                 elementToGiveFocus = elements.get(elements.size() - 1);
             }
             else if (index == 0) {
                 // first; back to the last
                 elementToGiveFocus = elements.get(elements.size() - 1);
             }
             else {
                 elementToGiveFocus = elements.get(index - 1);
             }
         }
 
         setFocusedElement(elementToGiveFocus);
         return elementToGiveFocus;
     }
 
     /**
      * Returns the HTML element with the specified ID. If more than one element
      * has this ID (not allowed by the HTML spec), then this method returns the
      * first one.
      *
      * @param elementId the ID value to search for
      * @param <E> the element type
      * @return the HTML element with the specified ID
      * @throws ElementNotFoundException if no element was found matching the specified ID
      */
     @SuppressWarnings("unchecked")
     public <E extends HtmlElement> E getHtmlElementById(final String elementId) throws ElementNotFoundException {
         final DomElement element = getElementById(elementId);
         if (element == null) {
             throw new ElementNotFoundException("*", DomElement.ID_ATTRIBUTE, elementId);
         }
         return (E) element;
     }
 
     /**
      * Returns the elements with the specified ID. If there are no elements
      * with the specified ID, this method returns an empty list. Please note that
      * the lists returned by this method are immutable.
      *
      * @param elementId the ID value to search for
      * @return the elements with the specified name attribute
      */
     public List<DomElement> getElementsById(final String elementId) {
         if (elementId != null) {
             ensureMappedElementsBuilt();
             final MappedElementIndexEntry elements = idMap_.get(elementId);
             if (elements != null) {
                 return new ArrayList<>(elements.elements());
             }
         }
         return Collections.emptyList();
     }
 
     /**
      * Returns the element with the specified name. If more than one element
      * has this name, then this method returns the first one.
      *
      * @param name the name value to search for
      * @param <E> the element type
      * @return the element with the specified name
      * @throws ElementNotFoundException if no element was found matching the specified name
      */
     @SuppressWarnings("unchecked")
     public <E extends DomElement> E getElementByName(final String name) throws ElementNotFoundException {
         if (name != null) {
             ensureMappedElementsBuilt();
             final MappedElementIndexEntry elements = nameMap_.get(name);
             if (elements != null) {
                 return (E) elements.first();
             }
         }
         throw new ElementNotFoundException("*", DomElement.NAME_ATTRIBUTE, name);
     }
 
     /**
      * Returns the elements with the specified name attribute. If there are no elements
      * with the specified name, this method returns an empty list. Please note that
      * the lists returned by this method are immutable.
      *
      * @param name the name value to search for
      * @return the elements with the specified name attribute
      */
     public List<DomElement> getElementsByName(final String name) {
         if (name != null) {
             ensureMappedElementsBuilt();
             final MappedElementIndexEntry elements = nameMap_.get(name);
             if (elements != null) {
                 return new ArrayList<>(elements.elements());
             }
         }
         return Collections.emptyList();
     }
 
     /**
      * Returns the elements with the specified string for their name or ID. If there are
      * no elements with the specified name or ID, this method returns an empty list.
      *
      * @param idAndOrName the value to search for
      * @return the elements with the specified string for their name or ID
      */
     public List<DomElement> getElementsByIdAndOrName(final String idAndOrName) {
         if (idAndOrName == null) {
             return Collections.emptyList();
         }
         ensureMappedElementsBuilt();
         final MappedElementIndexEntry list1 = idMap_.get(idAndOrName);
         final MappedElementIndexEntry list2 = nameMap_.get(idAndOrName);
         final List<DomElement> list = new ArrayList<>();
         if (list1 != null) {
             list.addAll(list1.elements());
         }
         if (list2 != null) {
             for (final DomElement elt : list2.elements()) {
                 if (!list.contains(elt)) {
                     list.add(elt);
                 }
             }
         }
         return list;
     }
 
     /**
      * <span style="color:red">INTERNAL API - SUBJECT TO CHANGE AT ANY TIME - USE AT YOUR OWN RISK.</span><br>
      *
      * @param node the node that has just been added to the document
      */
     void notifyNodeAdded(final DomNode node) {
         if (node instanceof DomElement element1) {
             addMappedElement(element1, true);
 
             if (node instanceof BaseFrameElement element) {
                 frameElements_.add(element);
             }
 
             if (node.getFirstChild() != null) {
                 for (final Iterator<HtmlElement> iterator = node.new DescendantHtmlElementsIterator();
                         iterator.hasNext();) {
                     final HtmlElement child = iterator.next();
                     if (child instanceof BaseFrameElement element) {
                         frameElements_.add(element);
                     }
                 }
             }
 
             if ("base".equals(node.getNodeName())) {
                 calculateBase();
             }
         }
 
         if (node instanceof DomDocumentType doctype && node.getParentNode() == this) {
             setDocumentType(doctype);
         }
         node.onAddedToPage();
     }
 
     /**
      * <span style="color:red">INTERNAL API - SUBJECT TO CHANGE AT ANY TIME - USE AT YOUR OWN RISK.</span><br>
      *
      * @param node the node that has just been removed from the tree
      */
     void notifyNodeRemoved(final DomNode node) {
         if (node instanceof HtmlElement element) {
             removeMappedElement(element, true, true);
 
             if (node instanceof BaseFrameElement) {
                 frameElements_.remove(node);
             }
             for (final HtmlElement child : node.getHtmlElementDescendants()) {
                 if (child instanceof BaseFrameElement) {
                     frameElements_.remove(child);
                 }
             }
 
             if ("base".equals(node.getNodeName())) {
                 calculateBase();
             }
             return;
         }
 
         if (node instanceof DomDocumentType && node == getDoctype()) {
             setDocumentType(null);
         }
     }
 
     /**
      * Adds an element to the ID and name maps, if necessary.
      * @param element the element to be added to the ID and name maps
      * @param recurse indicates if children must be added too
      */
     void addMappedElement(final DomElement element, final boolean recurse) {
         // Index is built lazily; skip while not built. ensureMappedElementsBuilt()
         // walks the tree once and populates everything on first read.
         if (!mappedElementsBuilt_) {
             return;
         }
         if (isAncestorOf(element)) {
             addElement(element, recurse);
         }
     }
 
     private void ensureMappedElementsBuilt() {
         if (mappedElementsBuilt_) {
             return;
         }
 
         final DomElement root = getDocumentElement();
         if (root != null) {
             addElement(root, true);
         }
 
         // Flip the flag only after the maps are populated, so a partial
         // failure mid-walk leaves us with built_=false and the next read
         // tries again rather than seeing a half-populated index.
         mappedElementsBuilt_ = true;
     }
 
     private void addElement(final DomElement element, final boolean recurse) {
         final String idValue = element.getAttribute(DomElement.ID_ATTRIBUTE);
         if (ATTRIBUTE_NOT_DEFINED != idValue) {
             MappedElementIndexEntry elements = idMap_.get(idValue);
             if (elements == null) {
                 elements = new MappedElementIndexEntry();
                 elements.add(element);
                 idMap_.put(idValue, elements);
             }
             else {
                 elements.add(element);
             }
         }
 
         final String nameValue = element.getAttribute(DomElement.NAME_ATTRIBUTE);
         if (ATTRIBUTE_NOT_DEFINED != nameValue) {
             MappedElementIndexEntry elements = nameMap_.get(nameValue);
             if (elements == null) {
                 elements = new MappedElementIndexEntry();
                 elements.add(element);
                 nameMap_.put(nameValue, elements);
             }
             else {
                 elements.add(element);
             }
         }
 
         if (recurse) {
             // poor man's approach - we don't use getChildElements()
             // to avoid a bunch of object constructions
             DomNode nextChild = element.getFirstChild();
             while (nextChild != null) {
                 if (nextChild instanceof DomElement domElement) {
                     addElement(domElement, true);
                 }
                 nextChild = nextChild.getNextSibling();
             }
         }
     }
 
     /**
      * Removes an element and optionally its children from the ID and name maps, if necessary.
      * @param element the element to be removed from the ID and name maps
      * @param recurse indicates if children must be removed too
      * @param descendant indicates of the element was descendant of this HtmlPage, but now its parent might be null
      */
     void removeMappedElement(final DomElement element, final boolean recurse, final boolean descendant) {
         // see addMappedElement: while the index is unbuilt, removals are also no-ops.
         if (!mappedElementsBuilt_) {
             return;
         }
         if (descendant || isAncestorOf(element)) {
             removeElement(element, recurse);
         }
     }
 
     private void removeElement(final DomElement element, final boolean recurse) {
         final String idValue = element.getAttribute(DomElement.ID_ATTRIBUTE);
         if (ATTRIBUTE_NOT_DEFINED != idValue) {
             final MappedElementIndexEntry elements = idMap_.remove(idValue);
             if (elements != null) {
                 elements.remove(element);
                 if (!elements.elements_.isEmpty()) {
                     idMap_.put(idValue, elements);
                 }
             }
         }
 
         final String nameValue = element.getAttribute(DomElement.NAME_ATTRIBUTE);
         if (ATTRIBUTE_NOT_DEFINED != nameValue) {
             final MappedElementIndexEntry elements = nameMap_.remove(nameValue);
             if (elements != null) {
                 elements.remove(element);
                 if (!elements.elements_.isEmpty()) {
                     nameMap_.put(nameValue, elements);
                 }
             }
         }
 
         if (recurse) {
             for (final DomElement child : element.getChildElements()) {
                 removeElement(child, true);
             }
         }
     }
 
     /**
      * Indicates if the attribute name indicates that the owning element is mapped.
      * @param document the owning document
      * @param attributeName the name of the attribute to consider
      * @return {@code true} if the owning element should be mapped in its owning page
      */
     static boolean isMappedElement(final Document document, final String attributeName) {
         return document instanceof HtmlPage
             && (DomElement.NAME_ATTRIBUTE.equals(attributeName) || DomElement.ID_ATTRIBUTE.equals(attributeName));
     }
 
     private void calculateBase() {
         final List<HtmlElement> baseElements = getDocumentElement().getStaticElementsByTagName("base");
 
         base_ = null;
         for (final HtmlElement baseElement : baseElements) {
             if (baseElement instanceof HtmlBase base) {
                 if (base_ != null) {
                     notifyIncorrectness("Multiple 'base' detected, only the first is used.");
                     break;
                 }
                 base_ = base;
             }
         }
     }
 
     /**
      * Loads the content of the contained frames. This is done after the page is completely loaded, to allow script
      * contained in the frames to reference elements from the page located after the closing &lt;/frame&gt; tag.
      * @throws FailingHttpStatusCodeException if the server returns a failing status code AND the property
      *         {@link WebClientOptions#setThrowExceptionOnFailingStatusCode(boolean)} is set to {@code true}
      */
     void loadFrames() throws FailingHttpStatusCodeException {
         for (final BaseFrameElement frameElement : new ArrayList<>(frameElements_)) {
             // test if the frame should really be loaded:
             // if a script has already changed its content, it should be skipped
             // use == and not equals(...) to identify initial content (versus URL set to "about:blank")
             if (frameElement.getEnclosedWindow() != null
                     && UrlUtils.URL_ABOUT_BLANK == frameElement.getEnclosedPage().getUrl()
                     && !frameElement.isContentLoaded()) {
                 frameElement.loadInnerPage();
             }
         }
     }
 
     /**
      * Gives a basic representation for debugging purposes.
      * @return a basic representation
      */
     @Override
     public String toString() {
         final StringBuilder builder = new StringBuilder()
             .append("HtmlPage(")
             .append(getUrl())
             .append(")@")
             .append(hashCode());
         return builder.toString();
     }
 
     /**
      * Gets the meta tag for a given {@code http-equiv} value.
      * @param httpEquiv the {@code http-equiv} value
      * @return a list of {@link HtmlMeta}
      */
     protected List<HtmlMeta> getMetaTags(final String httpEquiv) {
         if (getDocumentElement() == null) {
             return Collections.emptyList(); // weird case, for instance if document.documentElement has been removed
         }
         final List<HtmlMeta> tags = getDocumentElement().getStaticElementsByTagName("meta");
         final List<HtmlMeta> foundTags = new ArrayList<>();
         for (final HtmlMeta htmlMeta : tags) {
             if (httpEquiv.equalsIgnoreCase(htmlMeta.getHttpEquivAttribute())) {
                 foundTags.add(htmlMeta);
             }
         }
         return foundTags;
     }
 
     /**
      * Creates a clone of this instance, and clears cached state to be not shared with the original.
      *
      * @return a clone of this instance
      */
     @Override
     protected HtmlPage clone() {
         final HtmlPage result = (HtmlPage) super.clone();
         result.elementWithFocus_ = null;
 
         result.idMap_ = new ConcurrentHashMap<>();
         result.nameMap_ = new ConcurrentHashMap<>();
         result.mappedElementsBuilt_ = false;
 
         return result;
     }
 
     /**
      * {@inheritDoc}
      */
     @Override
     public HtmlPage cloneNode(final boolean deep) {
         // we need the ScriptObject clone before cloning the kids.
         final HtmlPage result = (HtmlPage) super.cloneNode(false);
         if (getWebClient().isJavaScriptEnabled()) {
             final HtmlUnitScriptable jsObjClone = getScriptableObject().clone();
             jsObjClone.setDomNode(result);
         }
 
         // if deep, clone the kids too, and re initialize parts of the clone
         if (deep) {
             // this was previously synchronized but that makes not sense, why
             // lock the source against a copy only one has a reference too,
             // because result is a local reference
             result.attributeListeners_ = null;
 
             result.selectionRanges_ = new ArrayList<>(3);
             // the original one is synchronized so we should do that here too, shouldn't we?
             result.afterLoadActions_ = Collections.synchronizedList(new ArrayList<>());
             result.frameElements_ = new ArrayList<>();
             for (DomNode child = getFirstChild(); child != null; child = child.getNextSibling()) {
                 result.appendChild(child.cloneNode(true));
             }
         }
         return result;
     }
 
     /**
      * Adds an HtmlAttributeChangeListener to the listener list.
      * The listener is registered for all attributes of all HtmlElements contained in this page.
      *
      * @param listener the attribute change listener to be added
      * @see #removeHtmlAttributeChangeListener(HtmlAttributeChangeListener)
      */
     public void addHtmlAttributeChangeListener(final HtmlAttributeChangeListener listener) {
         WebAssert.notNull("listener", listener);
         synchronized (lock_) {
             if (attributeListeners_ == null) {
                 attributeListeners_ = new LinkedHashSet<>();
             }
             attributeListeners_.add(listener);
         }
     }
 
     /**
      * Removes an HtmlAttributeChangeListener from the listener list.
      * This method should be used to remove HtmlAttributeChangeListener that were registered
      * for all attributes of all HtmlElements contained in this page.
      *
      * @param listener the attribute change listener to be removed
      * @see #addHtmlAttributeChangeListener(HtmlAttributeChangeListener)
      */
     public void removeHtmlAttributeChangeListener(final HtmlAttributeChangeListener listener) {
         WebAssert.notNull("listener", listener);
         synchronized (lock_) {
             if (attributeListeners_ != null) {
                 attributeListeners_.remove(listener);
             }
         }
     }
 
     /**
      * Notifies all registered listeners for the given event to add an attribute.
      * @param event the event to fire
      */
     void fireHtmlAttributeAdded(final HtmlAttributeChangeEvent event) {
         final List<HtmlAttributeChangeListener> listeners = safeGetAttributeListeners();
         if (listeners != null) {
             for (final HtmlAttributeChangeListener listener : listeners) {
                 listener.attributeAdded(event);
             }
         }
     }
 
     /**
      * Notifies all registered listeners for the given event to replace an attribute.
      * @param event the event to fire
      */
     void fireHtmlAttributeReplaced(final HtmlAttributeChangeEvent event) {
         final List<HtmlAttributeChangeListener> listeners = safeGetAttributeListeners();
         if (listeners != null) {
             for (final HtmlAttributeChangeListener listener : listeners) {
                 listener.attributeReplaced(event);
             }
         }
     }
 
     /**
      * Notifies all registered listeners for the given event to remove an attribute.
      * @param event the event to fire
      */
     void fireHtmlAttributeRemoved(final HtmlAttributeChangeEvent event) {
         final List<HtmlAttributeChangeListener> listeners = safeGetAttributeListeners();
         if (listeners != null) {
             for (final HtmlAttributeChangeListener listener : listeners) {
                 listener.attributeRemoved(event);
             }
         }
     }
 
     private List<HtmlAttributeChangeListener> safeGetAttributeListeners() {
         synchronized (lock_) {
             if (attributeListeners_ != null) {
                 return new ArrayList<>(attributeListeners_);
             }
             return null;
         }
     }
 
     /**
      * {@inheritDoc}
      */
     @Override
     protected void checkChildHierarchy(final org.w3c.dom.Node newChild) throws DOMException {
         if (newChild instanceof Element) {
             if (getDocumentElement() != null) {
                 throw new DOMException(DOMException.HIERARCHY_REQUEST_ERR,
                     "The Document may only have a single child Element.");
             }
         }
         else if (newChild instanceof DocumentType) {
             if (getDoctype() != null) {
                 throw new DOMException(DOMException.HIERARCHY_REQUEST_ERR,
                     "The Document may only have a single child DocumentType.");
             }
         }
         else if (!(newChild instanceof Comment || newChild instanceof ProcessingInstruction)) {
             throw new DOMException(DOMException.HIERARCHY_REQUEST_ERR,
                 "The Document may not have a child of this type: " + newChild.getNodeType());
         }
         super.checkChildHierarchy(newChild);
     }
 
     /**
      * Returns {@code true} if an HTML parser is operating on this page, adding content to it.
      * @return {@code true} if an HTML parser is operating on this page, adding content to it
      */
     public boolean isBeingParsed() {
         return parserCount_ > 0;
     }
 
     /**
      * <span style="color:red">INTERNAL API - SUBJECT TO CHANGE AT ANY TIME - USE AT YOUR OWN RISK.</span><br>
      *
      * Called by the HTML parser to let the page know that it has started parsing some content for this page.
      */
     public void registerParsingStart() {
         parserCount_++;
     }
 
     /**
      * <span style="color:red">INTERNAL API - SUBJECT TO CHANGE AT ANY TIME - USE AT YOUR OWN RISK.</span><br>
      *
      * Called by the HTML parser to let the page know that it has finished parsing some content for this page.
      */
     public void registerParsingEnd() {
         parserCount_--;
     }
 
     /**
      * <span style="color:red">INTERNAL API - SUBJECT TO CHANGE AT ANY TIME - USE AT YOUR OWN RISK.</span><br>
      *
      * Returns {@code true} if an HTML parser is parsing a non-inline HTML snippet to add content
      * to this page. Non-inline content is content that is parsed for the page, but not in the
      * same stream as the page itself -- basically anything other than <code>document.write()</code>
      * or <code>document.writeln()</code>: <code>innerHTML</code>, <code>outerHTML</code>,
      * <code>document.createElement()</code>, etc.
      *
      * @return {@code true} if an HTML parser is parsing a non-inline HTML snippet to add content
      *         to this page
      */
     public boolean isParsingHtmlSnippet() {
         return snippetParserCount_ > 0;
     }
 
     /**
      * <span style="color:red">INTERNAL API - SUBJECT TO CHANGE AT ANY TIME - USE AT YOUR OWN RISK.</span><br>
      *
      * Called by the HTML parser to let the page know that it has started parsing a non-inline HTML snippet.
      */
     public void registerSnippetParsingStart() {
         snippetParserCount_++;
     }
 
     /**
      * <span style="color:red">INTERNAL API - SUBJECT TO CHANGE AT ANY TIME - USE AT YOUR OWN RISK.</span><br>
      *
      * Called by the HTML parser to let the page know that it has finished parsing a non-inline HTML snippet.
      */
     public void registerSnippetParsingEnd() {
         snippetParserCount_--;
     }
 
     /**
      * <span style="color:red">INTERNAL API - SUBJECT TO CHANGE AT ANY TIME - USE AT YOUR OWN RISK.</span><br>
      *
      * Returns {@code true} if an HTML parser is parsing an inline HTML snippet to add content
      * to this page. Inline content is content inserted into the parser stream dynamically
      * while the page is being parsed (i.e. <code>document.write()</code> or <code>document.writeln()</code>).
      *
      * @return {@code true} if an HTML parser is parsing an inline HTML snippet to add content
      *         to this page
      */
     public boolean isParsingInlineHtmlSnippet() {
         return inlineSnippetParserCount_ > 0;
     }
 
     /**
      * <span style="color:red">INTERNAL API - SUBJECT TO CHANGE AT ANY TIME - USE AT YOUR OWN RISK.</span><br>
      *
      * Called by the HTML parser to let the page know that it has started parsing an inline HTML snippet.
      */
     public void registerInlineSnippetParsingStart() {
         inlineSnippetParserCount_++;
     }
 
     /**
      * <span style="color:red">INTERNAL API - SUBJECT TO CHANGE AT ANY TIME - USE AT YOUR OWN RISK.</span><br>
      *
      * Called by the HTML parser to let the page know that it has finished parsing an inline HTML snippet.
      */
     public void registerInlineSnippetParsingEnd() {
         inlineSnippetParserCount_--;
     }
 
     /**
      * Refreshes the page by sending the same parameters as previously sent to get this page.
      * @return the newly loaded page.
      * @throws IOException if an IO problem occurs
      */
     public Page refresh() throws IOException {
         return getWebClient().getPage(getWebResponse().getWebRequest());
     }
 
     /**
      * <span style="color:red">INTERNAL API - SUBJECT TO CHANGE AT ANY TIME - USE AT YOUR OWN RISK.</span><br>
      * <p>
      * Parses the given string as would it belong to the content being parsed
      * at the current parsing position
      * </p>
      * @param string the HTML code to write in place
      */
     public void writeInParsedStream(final String string) {
         getDOMBuilder().pushInputString(string);
     }
 
     /**
      * <span style="color:red">INTERNAL API - SUBJECT TO CHANGE AT ANY TIME - USE AT YOUR OWN RISK.</span><br>
      *
      * Sets the builder to allow page to send content from document.write(ln) calls.
      * @param htmlUnitDOMBuilder the builder
      */
     public void setDOMBuilder(final HTMLParserDOMBuilder htmlUnitDOMBuilder) {
         domBuilder_ = htmlUnitDOMBuilder;
     }
 
     /**
      * <span style="color:red">INTERNAL API - SUBJECT TO CHANGE AT ANY TIME - USE AT YOUR OWN RISK.</span><br>
      *
      * Returns the current builder.
      * @return the current builder
      */
     public HTMLParserDOMBuilder getDOMBuilder() {
         return domBuilder_;
     }
 
     /**
      * <p>Returns all namespaces defined in the root element of this page.</p>
      * <p>The default namespace has a key of an empty string.</p>
      * @return all namespaces defined in the root element of this page
      */
     public Map<String, String> getNamespaces() {
         final org.w3c.dom.NamedNodeMap attributes = getDocumentElement().getAttributes();
         final Map<String, String> namespaces = new HashMap<>();
         for (int i = 0; i < attributes.getLength(); i++) {
             final Attr attr = (Attr) attributes.item(i);
             String name = attr.getName();
             if (name.startsWith("xmlns")) {
                 int startPos = 5;
                 if (name.length() > 5 && name.charAt(5) == ':') {
                     startPos = 6;
                 }
                 name = name.substring(startPos);
                 namespaces.put(name, attr.getValue());
             }
         }
         return namespaces;
     }
 
     /**
      * {@inheritDoc}
      */
     @Override
     public void setDocumentType(final DocumentType type) {
         super.setDocumentType(type);
     }
 
     /**
      * Saves the current page, with all images, to the specified location.
      * The default behavior removes all script elements.
      *
      * @param file file to write this page into
      * @throws IOException If an error occurs
      */
     public void save(final File file) throws IOException {
         new XmlSerializer().save(this, file);
     }
 
     /**
      * Returns whether the current page mode is in {@code quirks mode} or in {@code standards mode}.
      * @return true for {@code quirks mode}, false for {@code standards mode}
      */
     public boolean isQuirksMode() {
         return "BackCompat".equals(((HTMLDocument) getScriptableObject()).getCompatMode());
     }
 
     /**
      * <span style="color:red">INTERNAL API - SUBJECT TO CHANGE AT ANY TIME - USE AT YOUR OWN RISK.</span><br>
      * {@inheritDoc}
      */
     @Override
     public boolean isAttachedToPage() {
         return true;
     }
 
     /**
      * {@inheritDoc}
      */
     @Override
     public boolean isHtmlPage() {
         return true;
     }
 
     /**
      * The base URL used to resolve relative URLs.
      * @return the base URL
      */
     public URL getBaseURL() {
         URL baseUrl;
         if (base_ == null) {
             baseUrl = getUrl();
             final WebWindow window = getEnclosingWindow();
             final boolean frame = window != null && window != window.getTopWindow();
             if (frame) {
                 final boolean frameSrcIsNotSet = baseUrl == UrlUtils.URL_ABOUT_BLANK;
                 final boolean frameSrcIsJs = "javascript".equals(baseUrl.getProtocol());
                 if (frameSrcIsNotSet || frameSrcIsJs) {
                     baseUrl = window.getTopWindow().getEnclosedPage().getWebResponse()
                         .getWebRequest().getUrl();
                 }
             }
             else if (baseUrl_ != null) {
                 baseUrl = baseUrl_;
             }
         }
         else {
             final String href = base_.getHrefAttribute().trim();
             if (org.htmlunit.util.StringUtils.isEmptyOrNull(href)) {
                 baseUrl = getUrl();
             }
             else {
                 final URL url = getUrl();
                 try {
                     if (href.startsWith("http://") || href.startsWith("https://")) {
                         baseUrl = new URL(href);
                     }
                     else if (href.startsWith("//")) {
                         baseUrl = new URL("%s:%s".formatted(url.getProtocol(), href));
                     }
                     else if (href.length() > 0 && href.charAt(0) == '/') {
                         final int port = Window.getPort(url);
                         baseUrl = new URL("%s://%s:%d%s".formatted(url.getProtocol(), url.getHost(), port, href));
                     }
                     else if (url.toString().endsWith("/")) {
                         baseUrl = new URL("%s%s".formatted(url, href));
                     }
                     else {
                         baseUrl = new URL(UrlUtils.resolveUrl(url, href));
                     }
                 }
                 catch (final MalformedURLException e) {
                     notifyIncorrectness("Invalid base url: \"" + href + "\", ignoring it");
                     baseUrl = url;
                 }
             }
         }
 
         return baseUrl;
     }
 
     /**
      * <span style="color:red">INTERNAL API - SUBJECT TO CHANGE AT ANY TIME - USE AT YOUR OWN RISK.</span><br>
      *
      * Adds an {@link AutoCloseable}, which would be closed during the {@link #cleanUp()}.
      * @param autoCloseable the autoclosable
      */
     public void addAutoCloseable(final AutoCloseable autoCloseable) {
         if (autoCloseable == null) {
             return;
         }
 
         if (autoCloseableList_ == null) {
             autoCloseableList_ = new ArrayList<>();
         }
         autoCloseableList_.add(autoCloseable);
     }
 
     /**
      * {@inheritDoc}
      */
     @Override
     public boolean handles(final Event event) {
         if (Event.TYPE_BLUR.equals(event.getType()) || Event.TYPE_FOCUS.equals(event.getType())) {
             return true;
         }
         return super.handles(event);
     }
 
     /**
      * Sets the {@link ElementFromPointHandler}.
      * @param elementFromPointHandler the handler
      */
     public void setElementFromPointHandler(final ElementFromPointHandler elementFromPointHandler) {
         elementFromPointHandler_ = elementFromPointHandler;
     }
 
     /**
      * <span style="color:red">INTERNAL API - SUBJECT TO CHANGE AT ANY TIME - USE AT YOUR OWN RISK.</span><br>
      *
      * Returns the element for the specified x coordinate and the specified y coordinate.
      *
      * @param x the x offset, in pixels
      * @param y the y offset, in pixels
      * @return the element for the specified x coordinate and the specified y coordinate
      */
     public HtmlElement getElementFromPoint(final int x, final int y) {
         if (elementFromPointHandler_ == null) {
             if (LOG.isWarnEnabled()) {
                 LOG.warn("ElementFromPointHandler was not specicifed for " + this);
             }
             if (x <= 0 || y <= 0) {
                 return null;
             }
             return getBody();
         }
         return elementFromPointHandler_.getElementFromPoint(this, x, y);
     }
 
     /**
      * Moves the focus to the specified element. This will trigger any relevant JavaScript
      * event handlers.
      *
      * @param newElement the element that will receive the focus, use {@code null} to remove focus from any element
      * @return true if the specified element now has the focus
      * @see #getFocusedElement()
      */
     public boolean setFocusedElement(final DomElement newElement) {
         return setFocusedElement(newElement, false);
     }
 
     /**
      * Moves the focus to the specified element. This will trigger any relevant JavaScript
      * event handlers.
      *
      * @param newElement the element that will receive the focus, use {@code null} to remove focus from any element
      * @param windowActivated - whether the enclosing window got focus resulting in specified element getting focus
      * @return true if the specified element now has the focus
      * @see #getFocusedElement()
      */
     public boolean setFocusedElement(final DomElement newElement, final boolean windowActivated) {
         if (elementWithFocus_ == newElement && !windowActivated) {
             // nothing to do
             return true;
         }
 
         final DomElement oldFocusedElement = elementWithFocus_;
         elementWithFocus_ = null;
 
         if (!windowActivated) {
             if (oldFocusedElement != null) {
                 oldFocusedElement.removeFocus();
                 oldFocusedElement.fireEvent(Event.TYPE_BLUR);
 
                 oldFocusedElement.fireEvent(Event.TYPE_FOCUS_OUT);
             }
         }
 
         elementWithFocus_ = newElement;
 
         // use newElement in the code below because element elementWithFocus_
         // might be changed by another thread
         if (newElement != null) {
             newElement.focus();
             newElement.fireEvent(Event.TYPE_FOCUS);
 
             newElement.fireEvent(Event.TYPE_FOCUS_IN);
         }
 
         // If a page reload happened as a result of the focus change then obviously this
         // element will not have the focus because its page has gone away.
         return this == getEnclosingWindow().getEnclosedPage();
     }
 
     /**
      * Returns the element with the focus or null if no element has the focus.
      * @return the element with focus or null
      * @see #setFocusedElement(DomElement)
      */
     public DomElement getFocusedElement() {
         return elementWithFocus_;
     }
 
     /**
      * <p><span style="color:red">INTERNAL API - SUBJECT TO CHANGE AT ANY TIME - USE AT YOUR OWN RISK.</span></p>
      *
      * Sets the element with focus.
      * @param elementWithFocus the element with focus
      */
     public void setElementWithFocus(final DomElement elementWithFocus) {
         elementWithFocus_ = elementWithFocus;
     }
 
     /**
      * <p><span style="color:red">INTERNAL API - SUBJECT TO CHANGE AT ANY TIME - USE AT YOUR OWN RISK.</span></p>
      * Returns the currently active element.
      *
      * @return the element that currently has focus, or the document's
      *         {@code body} element if no element has focus, or {@code null}
      *         if the document has no {@code body} element
      */
     public HtmlElement getActiveElement() {
         final DomElement activeElement = getFocusedElement();
         if (activeElement instanceof HtmlElement element) {
             return element;
         }
 
         final HtmlElement body = getBody();
         if (body != null) {
             return body;
         }
         return null;
     }
 
     /**
      * <p><span style="color:red">INTERNAL API - SUBJECT TO CHANGE AT ANY TIME - USE AT YOUR OWN RISK.</span></p>
      *
      * <p>Returns the page's current selection ranges.</p>
      *
      * @return the page's current selection ranges
      */
     public List<SimpleRange> getSelectionRanges() {
         return selectionRanges_;
     }
 
     /**
      * <p><span style="color:red">INTERNAL API - SUBJECT TO CHANGE AT ANY TIME - USE AT YOUR OWN RISK.</span></p>
      *
      * <p>Makes the specified selection range the *only* selection range on this page.</p>
      *
      * @param selectionRange the selection range
      */
     public void setSelectionRange(final SimpleRange selectionRange) {
         selectionRanges_.clear();
         selectionRanges_.add(selectionRange);
     }
 
     /**
      * <span style="color:red">INTERNAL API - SUBJECT TO CHANGE AT ANY TIME - USE AT YOUR OWN RISK.</span><br>
      *
      * Execute a Function in the given context.
      *
      * @param function the JavaScript Function to call
      * @param thisObject the "this" object to be used during invocation
      * @param args the arguments to pass into the call
      * @param htmlElement the HTML element for which this script is being executed
      *        This element will be the context during the JavaScript execution. If null,
      *        the context will default to the page.
      * @return a ScriptResult which will contain both the current page (which may be different from
      *        the previous page) and a JavaScript result object.
      */
     public ScriptResult executeJavaScriptFunction(final Object function, final Object thisObject,
             final Object[] args, final DomNode htmlElement) {
         if (!getWebClient().isJavaScriptEnabled()) {
             return new ScriptResult(null);
         }
 
         final JavaScriptEngine engine = (JavaScriptEngine) getWebClient().getJavaScriptEngine();
         final Object result = engine.callFunction(this,
                                 (Function) function, (Scriptable) thisObject, args, htmlElement);
 
         return new ScriptResult(result);
     }
 
     private void writeObject(final ObjectOutputStream oos) throws IOException {
         oos.defaultWriteObject();
         oos.writeObject(originalCharset_ == null ? null : originalCharset_.name());
     }
 
     private void readObject(final ObjectInputStream ois) throws ClassNotFoundException, IOException {
         ois.defaultReadObject();
         final String charsetName = (String) ois.readObject();
         if (charsetName != null) {
             originalCharset_ = Charset.forName(charsetName);
         }
     }
 
     /**
      * {@inheritDoc}
      */
     @Override
     public void setNodeValue(final String value) {
         // Default behavior is to do nothing, overridden in some subclasses
     }
 
     /**
      * {@inheritDoc}
      */
     @Override
     public void setPrefix(final String prefix) {
         // Empty.
     }
 
     /**
      * {@inheritDoc}
      */
     @Override
     public void clearComputedStyles() {
         if (computedStylesCache_ != null) {
             computedStylesCache_.clear();
         }
     }
 
     /**
      * {@inheritDoc}
      */
     @Override
     public void clearComputedStyles(final DomElement element) {
         if (computedStylesCache_ != null) {
             computedStylesCache_.remove(element);
         }
     }
 
     /**
      * {@inheritDoc}
      */
     @Override
     public void clearComputedStylesUpToRoot(final DomElement element) {
         if (computedStylesCache_ != null) {
             computedStylesCache_.remove(element);
 
             DomNode parent = element.getParentNode();
             while (parent != null) {
                 computedStylesCache_.remove(parent);
                 parent = parent.getParentNode();
             }
         }
     }
 
     /**
      * <span style="color:red">INTERNAL API - SUBJECT TO CHANGE AT ANY TIME - USE AT YOUR OWN RISK.</span><br>
      *
      * @param element the element to clear its cache
      * @param normalizedPseudo the pseudo attribute
      * @return the cached ComputedCssStyleDeclaration object or null
      */
     public ComputedCssStyleDeclaration getStyleFromCache(final DomElement element,
             final String normalizedPseudo) {
         return getCssPropertiesCache().get(element, normalizedPseudo);
     }
 
     /**
      * <span style="color:red">INTERNAL API - SUBJECT TO CHANGE AT ANY TIME - USE AT YOUR OWN RISK.</span><br>
      *
      * Caches a ComputedCssStyleDeclaration object.
      * @param element the element to clear its cache
      * @param normalizedPseudo the pseudo attribute
      * @param style the ComputedCssStyleDeclaration to cache
      */
     public void putStyleIntoCache(final DomElement element, final String normalizedPseudo,
             final ComputedCssStyleDeclaration style) {
         getCssPropertiesCache().put(element, normalizedPseudo, style);
     }
 
     /**
      * <span style="color:red">INTERNAL API - SUBJECT TO CHANGE AT ANY TIME - USE AT YOUR OWN RISK.</span><br>
      *
      * @return a list of all styles from this page (&lt;style&gt; and &lt;link rel=stylesheet&gt;).
      *         This returns an empty list if css support is disabled in the web client options.
      */
     public List<CssStyleSheet> getStyleSheets() {
         final List<CssStyleSheet> styles = new ArrayList<>();
         if (getWebClient().getOptions().isCssEnabled()) {
             for (final HtmlElement htmlElement : getHtmlElementDescendants()) {
                 if (htmlElement instanceof HtmlStyle style) {
                     styles.add(style.getSheet());
                     continue;
                 }
 
                 if (htmlElement instanceof HtmlLink link) {
                     if (link.isStyleSheetLink()) {
                         styles.add(link.getSheet());
                     }
                 }
             }
         }
         return styles;
     }
 
     /**
      * Returns the computed styles cache for this page.
      *
      * @return the computed styles cache for this page
      */
     private ComputedStylesCache getCssPropertiesCache() {
         if (computedStylesCache_ == null) {
             computedStylesCache_ = new ComputedStylesCache();
 
             // maintain the style cache
             final DomHtmlAttributeChangeListenerImpl listener = new DomHtmlAttributeChangeListenerImpl();
             addDomChangeListener(listener);
             addHtmlAttributeChangeListener(listener);
         }
         return computedStylesCache_;
     }
 
     /**
      * <p>Listens for changes anywhere in the document and evicts cached computed styles whenever something relevant
      * changes. Note that the very lazy way of doing this (completely clearing the cache every time something happens)
      * results in very meager performance gains. In order to get good (but still correct) performance, we need to be
      * a little smarter.</p>
      *
      * <p>CSS 2.1 has the following <a href="http://www.w3.org/TR/CSS21/selector.html">selector types</a> (where "SN" is
      * shorthand for "the selected node"):</p>
      *
      * <ol>
      *   <li><em>Universal</em> (i.e. "*"): Affected by the removal of SN from the document.</li>
      *   <li><em>Type</em> (i.e. "div"): Affected by the removal of SN from the document.</li>
      *   <li><em>Descendant</em> (i.e. "div span"): Affected by changes to SN or to any of its ancestors.</li>
      *   <li><em>Child</em> (i.e. "div &gt; span"): Affected by changes to SN or to its parent.</li>
      *   <li><em>Adjacent Sibling</em> (i.e. "table + p"): Affected by changes to SN or its previous sibling.</li>
      *   <li><em>Attribute</em> (i.e. "div.up, div[class~=up]"): Affected by changes to an attribute of SN.</li>
      *   <li><em>ID</em> (i.e. "#header"): Affected by changes to the <code>id</code> attribute of SN.</li>
      *   <li><em>Pseudo-Elements and Pseudo-Classes</em> (i.e. "p:first-child"): Affected by changes to parent.</li>
      * </ol>
      *
      * <p>Together, these rules dictate that the smart (but still lazy) way of removing elements from the computed style
      * cache is as follows -- whenever a node changes in any way, the cache needs to be cleared of styles for nodes
      * which:</p>
      *
      * <ul>
      *   <li>are actually the same node as the node that changed</li>
      *   <li>are siblings of the node that changed</li>
      *   <li>are descendants of the node that changed</li>
      * </ul>
      *
      * <p>Additionally, whenever a <code>style</code> node or a <code>link</code> node
      * with <code>rel=stylesheet</code> is added or
      * removed, all elements should be removed from the computed style cache.</p>
      */
     private class DomHtmlAttributeChangeListenerImpl implements DomChangeListener, HtmlAttributeChangeListener {
 
         /**
          * Ctor.
          */
         DomHtmlAttributeChangeListenerImpl() {
             super();
         }
 
         /**
          * {@inheritDoc}
          */
         @Override
         public void nodeAdded(final DomChangeEvent event) {
             nodeChanged(event.getChangedNode(), null);
         }
 
         /**
          * {@inheritDoc}
          */
         @Override
         public void nodeDeleted(final DomChangeEvent event) {
             nodeChanged(event.getChangedNode(), null);
         }
 
         /**
          * {@inheritDoc}
          */
         @Override
         public void attributeAdded(final HtmlAttributeChangeEvent event) {
             nodeChanged(event.getHtmlElement(), event.getName());
         }
 
         /**
          * {@inheritDoc}
          */
         @Override
         public void attributeRemoved(final HtmlAttributeChangeEvent event) {
             nodeChanged(event.getHtmlElement(), event.getName());
         }
 
         /**
          * {@inheritDoc}
          */
         @Override
         public void attributeReplaced(final HtmlAttributeChangeEvent event) {
             nodeChanged(event.getHtmlElement(), event.getName());
         }
 
         private void nodeChanged(final DomNode changedNode, final String attribName) {
             // If a stylesheet was changed, all of our calculations could be off; clear the cache.
             if (changedNode instanceof HtmlStyle) {
                 clearComputedStyles();
                 return;
             }
             if (changedNode instanceof HtmlLink link) {
                 if (link.isStyleSheetLink()) {
                     clearComputedStyles();
                     return;
                 }
             }
 
             // Apparently it wasn't a stylesheet that changed; be semi-smart about what we evict and when.
             // null means that a node was added/removed; we always have to take care of this for the parents
             final boolean clearParents = attribName == null || ATTRIBUTES_AFFECTING_PARENT.contains(attribName);
             if (computedStylesCache_ != null) {
                 computedStylesCache_.nodeChanged(changedNode, clearParents);
             }
         }
     }
 
     /**
      * Cache computed styles when possible, because their calculation is very expensive.
      * We use a weak hash map because we don't want this cache to be the only reason
      * nodes are kept around in the JVM, if all other references to them are gone.
      */
     private static final class ComputedStylesCache implements Serializable {
         private transient WeakHashMap<DomElement, Map<String, ComputedCssStyleDeclaration>>
                     computedStyles_ = new WeakHashMap<>();
 
         /**
          * Ctor.
          */
         ComputedStylesCache() {
             super();
         }
 
         public synchronized ComputedCssStyleDeclaration get(final DomElement element,
                 final String normalizedPseudo) {
             final Map<String, ComputedCssStyleDeclaration> elementMap = computedStyles_.get(element);
             if (elementMap != null) {
                 return elementMap.get(normalizedPseudo);
             }
             return null;
         }
 
         public synchronized void put(final DomElement element,
                 final String normalizedPseudo, final ComputedCssStyleDeclaration style) {
             final Map<String, ComputedCssStyleDeclaration>
                     elementMap = computedStyles_.computeIfAbsent(element, k -> new WeakHashMap<>());
             elementMap.put(normalizedPseudo, style);
         }
 
         public synchronized void nodeChanged(final DomNode changed, final boolean clearParents) {
             final Iterator<Map.Entry<DomElement, Map<String, ComputedCssStyleDeclaration>>>
                     i = computedStyles_.entrySet().iterator();
             while (i.hasNext()) {
                 final Map.Entry<DomElement, Map<String, ComputedCssStyleDeclaration>> entry = i.next();
                 final DomElement node = entry.getKey();
                 if (changed == node
                     || changed.getParentNode() == node.getParentNode()
                     || changed.isAncestorOf(node)
                     || clearParents && node.isAncestorOf(changed)) {
                     i.remove();
                 }
             }
 
             // maybe this is a better solution but I have to think a bit more about this
             //
             //            if (computedStyles_.isEmpty()) {
             //                return;
             //            }
             //
             //            // remove all siblings
             //            DomNode parent = changed.getParentNode();
             //            if (parent != null) {
             //                for (DomNode sibling : parent.getChildNodes()) {
             //                    computedStyles_.remove(sibling.getScriptableObject());
             //                }
             //
             //                if (clearParents) {
             //                    // remove all parents
             //                    while (parent != null) {
             //                        computedStyles_.remove(parent.getScriptableObject());
             //                        parent = parent.getParentNode();
             //                    }
             //                }
             //            }
             //
             //            // remove changed itself and all descendants
             //            computedStyles_.remove(changed.getScriptableObject());
             //            for (DomNode descendant : changed.getDescendants()) {
             //                computedStyles_.remove(descendant.getScriptableObject());
             //            }
         }
 
         public synchronized void clear() {
             computedStyles_.clear();
         }
 
         public synchronized Map<String, ComputedCssStyleDeclaration> remove(final DomNode element) {
             return computedStyles_.remove(element);
         }
 
         private void readObject(final ObjectInputStream in) throws IOException, ClassNotFoundException {
             in.defaultReadObject();
             computedStyles_ = new WeakHashMap<>();
         }
     }
 
     private static final class MappedElementIndexEntry implements Serializable {
         private final ArrayList<DomElement> elements_;
         private boolean sorted_;
 
         MappedElementIndexEntry() {
             // we do not expect to many elements having the same id/name
             elements_ = new ArrayList<>(2);
             sorted_ = true;
         }
 
         void add(final DomElement element) {
             if (elements_.indexOf(element) == -1) {
                 elements_.add(element);
                 sorted_ = elements_.size() < 2;
             }
         }
 
         DomElement first() {
             if (elements_.isEmpty()) {
                 return null;
             }
 
             if (sorted_) {
                 return elements_.get(0);
             }
 
             elements_.sort(DOCUMENT_POSITION_COMPERATOR);
             sorted_ = true;
 
             return elements_.get(0);
         }
 
         List<DomElement> elements() {
             if (sorted_) {
                 return elements_;
             }
 
             elements_.sort(DOCUMENT_POSITION_COMPERATOR);
             sorted_ = true;
 
             return elements_;
         }
 
         void remove(final DomElement element) {
             elements_.remove(element);
             sorted_ = elements_.size() < 2;
         }
     }
 }