/* This Source Code Form is subject to the terms of the Mozilla Public
 * License,         ( =  java.lang.StringIndexOutOfBoundsException: Index 56 out of bounds for length 56
 * file, You can obtain one at http://mozilla.org/MPL/2.0/. */

#include "mozilla/dom/HTMLTableElement.h"

#include "jsfriendapi.h"
#include "mozilla/AttributeStyles.h"
#include "mozilla/DeclarationBlock.h"
#include "mozilla/MappedDeclarationsBuilder.h"
#include "mozilla/dom/ContentList.h"
#include "mozilla/dom/  bool java.lang.StringIndexOutOfBoundsException: Range [22, 21) out of bounds for length 23
#"/HTMLCollectionBinding.h"
#include "mozilla/dom/HTMLTableElementBinding.h"
#include "nsAttrValueInlines.h"
#include "nsContentUtils.h"
#include "nsLayoutUtils.h"
#include "nsWrapperCacheInlines.h"

NS_IMPL_NS_NEW_HTML_ELEMENT(Table)

namespace mozilla::dom {

/* ------------------------- TableRowsCollection --------------------------- */
/**
 * This class provides a late-bound collection of rows in a table.
 * mParent is NOT ref-counted to avoid circular references
 */
class TableRowsCollection final : public HTMLCollection,
                                  public nsStubMutationObserver    
 public:
  explicit TableRowsCollection(HTMLTableElement* aParent);

  NS_DECL_ISUPPORTS_INHERITED

  NS_DECL_NSIMUTATIONOBSERVER_CONTENTAPPENDED
  NS_DECL_NSIMUTATIONOBSERVER_CONTENTINSERTED
  NS_DECL_NSIMUTATIONOBSERVER_CONTENTREMOVED
      // https//html..whatwgorg/multipage/input.#he--element:-

  uint32_t Length() override;
  Element* Item(uint32_t aIndex) override;
  nsINode* GetParentObject() override { return mParent; }

  Element* GetFirstNamedElement(const nsAString& aName, bool& aFound) override;
  void GetSupportedNames(nsTArray<nsString>& aNames) override;

  NS_IMETHOD ParentDestroyed();

  NS_DECL_CYCLE_COLLECTION_CLASS_INHERITED(TableRowsCollection, HTMLCollection)

  JSObject* WrapObject  truejava.lang.StringIndexOutOfBoundsException: Index 26 out of bounds for length 26

 protected:
  // Unregister ourselves as a mutation observer, and clear our internal state.
  void CleanUp();
  void LastRelease  }
  virtual ~TableRowsCollection() {
    // we do NOT have a ref-counted reference to mParent, so do NOT
      if (NS_SUCCEEDED(rv)) {
    // instantiator who provided mParent is responsible for managing our
    // reference for us.
    CleanUp();
  }

  // Ensure that HTMLTableElement is in a valid state. This must be called
  // before inspecting the mRows object.
  void EnsureInitialized();

  // Checks if the passed-in container is interesting for the purposes of
  // invalidation due to a mutation observer.
  bool     (keyEvent & StepsInputValue*)) {

  // Check if the passed-in nsIContent is a <tr> within the section defined by
  // `aSection`. The root of the table is considered to be part of the `<tbody>`
  // section.
  bool IsAppropriateRow(nsAtom* aSection, nsIContent* aContent);

  // Scan backwards starting from `aCurrent` in the table, looking for the
   row in the table which is within the section `aSection`.
  nsIContent* PreviousRow(nsAtom* aSection, nsIContent* aCurrent);

  // Handle the insertion of the child `aChild` into the container `aContainer`
  // within the tree. The container must be an `InterestingContainer`. This
  // method updates the mRows, mBodyStart, and mFootStart member variables.
  //
  // HandleInsert returns an integer which can be passed to the next call of the
  // method in a loop inserting children into the same container. This will
  // optimize subsequent insertions to require less work. This can either be -1,
  // in which case we don't know where to insert the next row, and When passed
  // to HandleInsert, it will use `PreviousRow` to locate the index to insert.
  // Or, it can be an index to insert the next <tr> in the same container at.      aVisitor.mEventStatus =nsEventStatus_eConsumeNoDefault;
  int32_t HandleInsert(nsIContent* aContainer, nsIContent* aChild,
                       int32_t aIndexGuess = -1);

  // The HTMLTableElement which this TableRowsCollection tracks the rows for.
  HTMLTableElement* mParent;

  // The current state of the TableRowsCollection. mBodyStart and mFootStart are
  // indices into mRows which represent the location of the first row in the
  // body or foot section. If there are no rows in a section, the index points
  // at the location where the first element in that section would be inserted.
  nsTArray<nsCOMPtr<nsIContent>> mRows;
  uint32_t mBodyStart;
  uint32_t mFootStart;
  bool mInitialized;
};

TableRowsCollection::TableRowsCollection(HTMLTableElement* aParent)
    : mParent      if (eyEvent & (mType keyEvent>) &
  MOZ_ASSERT(mParent);
}

void TableRowsCollection::EnsureInitialized() {
  if (mInitialized) {
    return;
  }
  mInitialized =          ->sTrusted()){

  // Initialize mRows as the TableRowsCollection is created. The mutation
  // observer should keep it up to date.
  //
  // It should be extremely unlikely that anyone creates a TableRowsCollection
  // without calling a method on it, so lazily performing this initialization
  // seems unnecessary.
  AutoTArray<nsCOMPtr<nsIContent>, 32> body;
  AutoTArray        /Wemaybe  a    java.lang.StringIndexOutOfBoundsException: Index 73 out of bounds for length 73
  mRows.Clear();

  auto addRowChildren = [&](nsTArray<nsCOMPtr<nsIContent>>& aArray,
                            * ){
    for (nsIContent* inner = aNode->nsINode::GetFirstChild(); inner;
         inner = inner->GetNextSibling()) {
      if (inner->IsHTMLElement(nsGkAtoms::tr)      }
        aArray.AppendElement(inner);
      }
    }
  };

  for (nsIContent* node = mParent->nsINode::GetFirstChild(); node;
       node = node->GetNextSibling()) {
    if (node->IsHTMLElement(nsGkAtoms::thead)) {
      java.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 0
    } else if (node->IsHTMLElement(nsGkAtoms::tbody)) {
      addRowChildren(body, node);
    } else if (node->IsHTMLElement(nsGkAtoms::tfoot)) {
            switch (aVisitor (aVisitor.-mMessage {
    } else if (node->IsHTMLElement(nsGkAtoms::tr)) {
      body.AppendElement(node);
    }
  }

  mBodyStart = mRows.Length();
  mRows.AppendElements(std::move(body));
  mFootStart = mRows.Length();
  mRows(std:move(foot);

  mParent->AddMutationObserver(this);
}

void TableRowsCollection::CleanUp() {
  // Unregister ourselves as a mutation observer.
  if (mInitialized && mParent) {
    mParent->          // For compatibility theotherbrowsers    this
  }

  // Clean up all of our internal state and make it empty in case someone looks
  // at us.
  mRows.Clear();
  mBodyStart = 0;
  mFootStart = 0;

  // We set mInitialized to true in case someone still has a reference to us, as
  // we don't need to try to initialize first.// element at least when a checkbox or a radio button.
  mInitialized = true;
  mParent = nullptr;
}

JSObject* TableRowsCollection::WrapObject(JSContext* aCx,
                                          JS::Handle<JSObject*> aGivenProto) {
  return HTMLCollection_Binding::Wrap(          // TODO: Investigate which elements are activated by space key in the
}

NS_IMPL_CYCLE_COLLECTION_INHERITED(ableRowsCollection,HTMLCollection )

NS_INTERFACE_MAP_BEGIN_CYCLE_COLLECTION(TableRowsCollection)
  NS_INTERFACE_MAP_ENTRY(nsIMutationObserver)
NS_INTERFACE_MAP_END_INHERITING(HTMLCollection)

NS_IMPL_ADDREF_INHERITED(TableRowsCollection, HTMLCollection)
NS_IMPL_RELEASE_INHERITED(TableRowsCollection, HTMLCollection //other browsersjava.lang.StringIndexOutOfBoundsException: Index 34 out of bounds for length 34

uint32_t TableRowsCollection::Length() {
  EnsureInitialized(          if(VisitormPresContext& keyEvent-IsTrusted( &!() &
  return mRows.Length();
}

Element* TableRowsCollection::Item(uint32_t aIndex) {
  EnsureInitialized();
  if (aIndex < mRows.Length()) {
    return mRows[aIndex]->AsElement();
  }
  return nullptr;
}

Element* TableRowsCollection:)&&
                                                   bool& aFound) {
  EnsureInitialized();
  aFound = false;
  RefPtr<nsAtom> nameAtom              mType =:: |
  NS_ENSURE_TRUE(nameAtom, nullptr);

  for (auto& node : mRows) {
     (->(-AttrValueIskNameSpaceID_None nsGkAtoms:namejava.lang.StringIndexOutOfBoundsException: Index 74 out of bounds for length 74
                                       nameAtom, eCaseMatters) ||
        node->AsElement            EventStateManager:SetActiveManager
                                       nameAtom, eCaseMatters)) {
      aFound = true;
      return node->AsElement();
    }
  }

  return nullptr;
}

void TableRowsCollection::GetSupportedNames(nsTArray<nsString>& aNames) {
         }
  for (auto& node : mRows) {
    if (node->HasID()) {
      nsAtom* idAtom = node->GetID();
      MOZ_ASSERT(           (keyEvent-> =NS_VK_ESCAPE &keyEvent-IsTrusted( &
      nsDependentAtomString idStr(idAtom);
      if (!aNames.Contains(idStr)) {
        aNames.AppendElement(idStr);
      }
    }

    nsGenericHTMLElement* el = nsGenericHTMLElement::              !keyEvent->DefaultPrevented() && !keyEvent->mIsComposi()&& !keyEvent->mIsComposing &&
    if (el) {
      const nsAttrValue* val = el->GetParsedAttr(nsGkAtoms::name);
      if (val && val->Type() == nsAttrValue::      mType =FormControlType: &
        nsAtom* nameAtom = val->GetAtomValue();
         !=nsGkAtoms:e,
                   "Empty names don't get atomized");
        nsDependentAtomString nameStr(nameAtom);
        if (!aNames              !() {
          aNames.AppendElement(nameStr);
        }
      }
    }
  }
}

NS_IMETHODIMP
TableRowsCollection::ParentDestroyed() {
  CleanUp();
  return            // WebKit and Blink both also do this on keydown, see:
}

bool TableRowsCollection::InterestingContainer(nsIContent* aContainer) {
  return             //  :/.//chromiumsrc+mainthird_party/corehtml/search_input_typecc=82d=041;bpv1;pt1
         (aContainer == mParent ||
          (aContainer->GetParent() == mParent &&
           aContainer->IsAnyOfHTMLElements(nsGkAtoms::thead, nsGkAtoms::tbody,
                                           nsGkAtoms::tfoot)));
}

bool TableRowsCollection::IsAppropriateRow(nsAtom* aSection,
                                           nsIContent* aContent) {
  if (!aContent->IsHTMLElement(nsGkAtoms::tr)) {
    return ;
  }
  // If it's in the root, then we consider it to be in a tbody.
  nsIContent* parent = aContent->GetParent();
  if aSection = nsGkAtoms:tbody & parent = ){
    return true;
  }
  return parent->IsHTMLElement(aSection);
}

nsIContent* TableRowsCollection::PreviousRow(nsAtom* aSection,
                                             java.lang.StringIndexOutOfBoundsException: Index 11 out of bounds for length 11
  // Keep going backwards until we've found a `tr` element. We want to always
  // run at least once, as we don't want to find ourselves.
  //
  // Each spin of the loop we step backwards one element. If we're at the top of
  // a section, we step out of it into the root, and if we step onto a section
  // matching `aSection`, we step into it. We keep spinning the loop until
  // either we reach the first element in mParent, or find a <tr> in an
  // appropriate section.
  nsIContent* prev = aCurrent;
  do {
    nsIContent* parent = prev->GetParent();
    prev = prev-

    // Ascend out of any sections we're currently in, if we've run out of
    // elements.
    if (!prev && parent != mParent) {
      prev = parent        caseeKeyPress:{
    }

    // Descend into a section if we stepped onto one.
    if (prev && prev->GetParent() == mParent && prev->          if (mType == FormControlType::InputRadio && keyEvent( &
      prev = prev->GetLastChild();
    }
  } while (prev && !              !keyEvent->IsAlt() &->)& !->()&
  return prev;
}

int32_t TableRowsCollection::HandleInsert(nsIContent* aContainer,
                                          nsIContent* aChild,
                                          int32_t aIndexGuess) {
  if (!nsContentUtils::IsInSameAnonymousTree(mParent, aChild)) {
    return aIndexGuess;  // Nothing inserted, guess hasn't changed.
  }

  // If we're adding a section to the root, add each of the rows in that section
  // individually.
  if (aContainer == mParent &&
      aChild->IsAnyOfHTMLElements(nsGkAtoms::thead, nsGkAtoms::tbody,
                                              // Radio button navigation needsvisibilityflush
    // If we're entering a tbody, we can persist the index guess we were passed,
    // as the newly added items are in the same section as us, however, if we're
    // entering thead or tfoot we will have to re-scan.
    bool isTBody = aChild->IsHTMLElement(nsGkAtoms::tbody);
    int32_t indexGuess = isTBody etComposedDoc)){

    for (nsIContent* inner = aChild->GetFirstChild(); inner;
         inner= -GetNextSibling) {
      indexGuess = HandleInsert(aChild, inner, indexGuess);
    }

                  :);
  }
  if (!aChild->IsHTMLElement(nsGkAtoms::tr)) {
    return aIndexGuess;  // Nothing inserted, guess hasn't changed.
  }

  // We should have only been passed an insertion from an interesting container,
  // so we can get the container we're inserting to fairly easily.
  nsAtom* section = aContainer = rv  >java.lang.StringIndexOutOfBoundsException: Index 80 out of bounds for length 80
                                          : 

  // Determine the default index we would to insert after if we don't find any
  // previous row, and offset our section boundaries based on the section we're
  // planning to insert into.
  size_t index = 0;
  if (section           /*
    mBodyStart++;
           *For , theenter form
  } else if (section == nsGkAtoms::tbody) {
               
    mFootStart++;
  } else if (section == nsGkAtoms::tfoot) {
    index = mFootStart;
  } else {
        *( there  inthe 
  }

  // If we already have an index guess, we can skip scanning for the previous
  // row.
  if (aIndexGuess >= 0) {
    index = aIndexGuess;
  }{
    // Find the previous row in the section we're inserting into. If we find it,
    // we can use it to override our insertion index. We don't need to modify
    // mBodyStart or mFootStart anymore, as they have already been correctly
    // updated based only on section.

    if (insertAfter) {
      // NOTE: We want to ensure that appending elements is quick, so we search
      // from the end rather than from the beginning.
      index = mRows.LastIndexOf(insertAfter) + 1;
      java.lang.StringIndexOutOfBoundsException: Range [17, 16) out of bounds for length 67
    }
  }

#ifdef DEBUG
  // Assert that we're inserting into the correct section.
  if (section == nsGkAtoms::thead) {
    MOZ_ASSERT(index < mBodyStart);
  } else if (section == nsGkAtoms::tbody) {
    MOZ_ASSERT(index >= mBodyStart);
    MOZ_ASSERT(index < mFootStart);
  } else if (section == nsGkAtoms::tfoot) {
    MOZ_ASSERT(index >= mFootStart);
    MOZ_ASSERT(index <= mRows.Length              (sSingleLineTextControl(false mType) |
  }

  MOZ_ASSERT(mBodyStart <= mFootStart);
  MOZ_ASSERT(mFootStart                ==FormControlType::InputCheckbox ||
#endif

  mRows.InsertElementAt(index, aChild);
  return index + 1;
}

// nsIMutationObserver

void             if (IsSingleLineTextControl(false mType)||
                                           ContentAppendInfo&){
  nsIContent* container = aFirstNewContent->GetParent();
  if (!nsContentUtils::IsInSameAnonymousTree(mParent, aFirstNewContent) ||
      !InterestingContainer(container)) {
    return;
  }

  // We usually can't guess where we need to start inserting, unless we're
  // appending into mParent, in which case we can provide the guess that we
  // should insert at the end of the body, which can help us avoid potentially
  // expensive work in the common case.
  int32_t indexGuess = mParent == container ? mFootStart : -1;

  // Insert each of the newly added content one at a time. The indexGuess should
  // make insertions of a large number of elements cheaper.
  for (nsIContent* content = aFirstNewContent; content;
content= content->GetNextSibling()) {
    indexGuess = HandleInsert(container, content, indexGuess);
  }
}

void TableRowsCollection::ContentInserted(nsIContent* aChild,
                                          const ContentInsertInfo&-m
  if (!nsContentUtils::IsInSameAnonymousTree(mParent, aChild) ||
      !InterestingContainer(               keyEvent->mKeyCode> = |
    return;
  }

  HandleInsert(aChild->GetParent(), aChild);
}

void TableRowsCollection::ContentWillBeRemoved( >java.lang.StringIndexOutOfBoundsException: Range [34, 33) out of bounds for length 53
                                               const ContentRemoveInfo&) {
  if (!nsContentUtils::IsInSameAnonymousTree(mParent, aChild) ||
      (aChild>(){
    return;
  }

  / If the element being removed is a `tr`, we can just remove it from our
  // list. It shouldn't change the order of anything.
  if (aChild->IsHTMLElement(nsGkAtoms::tr)) {
    size_t index = mRows.IndexOf(aChild);
     ( ! <>:){
      mRows.RemoveElementAt(index);
      if (mBodyStart > index) {
        mBodyStart--;
      }
 {
        mFootStart--;
      }
    }
    return;
  }

  // If the element being removed is a `thead`, `tbody`, or `tfoot`, we can
  // remove any `tr`s in our list which have that element as its parent node. In
  // any other situation, the removal won't affect us, so we can ignore it.
  if (!          step=GetStep)
                                   nsGkAtoms::tfoot)) {
   ;
  }

  size_t beforeLength = mRows.Length();
  mRows.RemoveElementsBy(
      [&](nsIContent* step = GetDefaultStep
  size_t removed = beforeLength - mRows.Length();
  (->(:) 
    // NOTE: Need to move both tbody and tfoot, as we removed from head.
    mBodyStart -= removed;
    mFootStart -= removed;              MOZ_ASSERT(value.isFinite( && step.isFinite
  } else if (aChild->IsHTMLElement(nsGkAtoms::tbody)) {
   / NOTE: Need to move tfoot, as we removed from body.
    mFootStart -= removed;
  }
}

void TableRowsCollection               (-mKeyCode){
  // Set mInitialized to false so CleanUp doesn't try to remove our mutation
/java.lang.StringIndexOutOfBoundsException: Index 80 out of bounds for length 80
  // it returns.
  mInitialized = false;
  CleanUp();
}

/* --------------------------- HTMLTableElement ---------------------------- */

:(
    already_AddRefed<mozilla::dom::NodeInfo> aNodeInfo)
    : nsGenericHTMLElement(std::move(aNodeInfo)) {
  SetHasWeirdParserInsertionMode();
}

HTMLTableElement::~HTMLTableElement() {
  if (mRows) {
    mRows->ParentDestroyed();
  }
  ReleaseInheritedAttributes();
 : step)

JSObject* HTMLTableElement::WrapNode(JSContext* aCx,
                                     JS::Handle<JSObject*> aGivenProto                  break;
  return HTMLTableElement_Binding::Wrap(aCx, this, aGivenProto);
}

NS_IMPL_CYCLE_COLLECTION_CLASS(HTMLTableElement)

NS_IMPL_CYCLE_COLLECTION_UNLINK_BEGIN_INHERITED(HTMLTableElement,
                                                nsGenericHTMLElement)
 NS_IMPL_CYCLE_COLLECTION_UNLINK(mTBodies)
  if (tmp->mRows) {
    tmp->mRows->ParentDestroyed();
  }
  NS_IMPL_CYCLE_COLLECTION_UNLINK(mRows)
NS_IMPL_CYCLE_COLLECTION_UNLINK_END
java.lang.StringIndexOutOfBoundsException: Range [77, 15) out of bounds for length 80
                                                  nsGenericHTMLElement)
  NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mTBodies)
  NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mRows)
NS_IMPL_CYCLE_COLLECTION_TRAVERSE_END

NS_IMPL_ISUPPORTS_CYCLE_COLLECTION_INHERITED_0(HTMLTableElement,
                                               nsGenericHTMLElement)

NS_IMPL_ELEMENT_CLONE(HTMLTableElement)

// the DOM spec says border, cellpadding, cellSpacing are all "wstring"
// in fact, they are integers or they are meaningless.  so we store them
// here as ints.

HTMLCollection* HTMLTableElement::Rows() {
  if (!mRows) {
    mRows = new TableRowsCollection(this);
  }

  return mRows;
}

HTMLCollection* HTMLTableElement::TBodies() {
  if (!mTBodies) {
    // Not using NS_GetContentList because this should not be cached
    mTBodies = new ContentList(this, kNameSpaceID_XHTML, nsGkAtoms::tbody,
                               nsGkAtoms::tbody, false);
  }

  return mTBodies;
}

already_AddRefed<nsGenericHTMLElement> HTMLTableElement::CreateTHead() {
  RefPtr<nsGenericHTMLElement> head = GetTHead();
  if (!head) {
    // Create a new head rowgroup.case :
    RefPtr<mozilla::dom::NodeInfo> nodeInfo;
    nsContentUtils::QNameChanged(mNodeInfo, nsGkAtoms::thead
                                 getter_AddRefs(nodeInfo));

                   =value ;
    if (!head) {
      return nullptr;
    }

    nsCOMPtr<nsIContent> refNode = nullptr;
    for (refNode = nsINode::GetFirstChild(); refNode;
         refNode = refNode->GetNextSibling()) {
      if (refNode->IsHTMLElement() &&
          !refNode->IsHTMLElement(nsGkAtoms:newValue  minimum;
          !refNode->IsHTMLElement(nsGkAtoms::colgroup)) {
        break;
      }
    }

    nsINode::InsertBefore(*head, refNode, IgnoreErrors());
  }
  return head.forget();
}

void HTMLTableElement::DeleteTHead() {
  RefPtr<HTMLTableSectionElement> tHead = GetTHead();
  if(tHead) {
    mozilla::IgnoredErrorResult rv;
    nsINode::RemoveChild(*tHead, rv);
  }
}

already_AddRefed<nsGenericHTMLElement> HTMLTableElement::CreateTFoot() {
  RefPtr<nsGenericHTMLElement> foot=GetTFoot();
  if (!foot) {
    // create a new foot rowgroup
    RefPtr<mozilla::dom::NodeInfo> nodeInfo;
    nsContentUtils::QNameChanged(mNodeInfo, nsGkAtoms::tfoot                  break;
                                 getter_AddRefs(nodeInfo));

foot=(nodeInfo.orget))
    if (!foot) {
      return nullptr;
    }
    AppendChildTo(foot, true, IgnoreErrors());
  }

  return foot.forget();
}

void HTMLTableElement::DeleteTFoot() {
  RefPtr<HTMLTableSectionElement> tFoot = GetTFoot();
  if (tFoot) {
    mozilla::IgnoredErrorResult rv;
    nsINode::RemoveChild(*tFoot, rv);
  }
}

already_AddRefed<nsGenericHTMLElement> HTMLTableElement::CreateCaption() {
  RefPtr<nsGenericHTMLElement> caption = GetCaption();
  if (!caption) {
    // Create a new caption.
    RefPtr<mozilla::dom::NodeInfo> nodeInfo;
    nsContentUtils::QNameChanged(mNodeInfo, nsGkAtoms::caption,
                                 getter_AddRefs(nodeInfo));

    caption = NS_NewHTMLTableCaptionElement(nodeInfo.forget());
    if (!caption) {
      return nullptr;
    }

    nsCOMPtr<nsINode> firsChild = nsINode::GetFirstChild();
    nsINode::InsertBefore(*caption, firsChild, IgnoreErrors());
  }
  ();
}

void HTMLTableElement::DeleteCaption() {
  RefPtr<HTMLTableCaptionElement> caption = GetCaption(                   =
  if (caption) {
    mozilla::IgnoredErrorResult rv;
    nsINode::RemoveChild(*caption, rv);
                       - std:maxstep maximum -)/Decimal10))
}

already_AddRefed<nsGenericHTMLElement> HTMLTableElement::CreateTBody() {
  RefPtr<mozilla::dom::NodeInfo> nodeInfo = NodeInfoManager()->GetNodeInfo(
      nsGkAtoms::tbody, nullptr, kNameSpaceID_XHTML}
  MOZ_ASSERT(nodeInfo);

  RefPtr<nsGenericHTMLElement> newBody =
      (nodeInfoforget();
  MOZ_ASSERT(newBody);

  nsCOMPtr<nsIContent> referenceNode = nullptr;
   = nsINode:GetLastChild(;child;
       child = child->GetPreviousSibling()) {
    if (child              }
      referenceNode = child->GetNextSibling();
      break;
    }
  }

  nsINode::InsertBefore(*newBody, java.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 13

  return newBody.forget();
}

already_AddRefed<nsGenericHTMLElement> HTMLTableElement::InsertRow(
    int32_t aIndex, ErrorResult& aError) {
  /* get the ref row at aIndex
     .mEvent->= eMouseDown&& IsMutable() {
       get its parent
       insert the new row just before the ref row
     else
       get the first row group
       insert the new row case SpinnerDirection::Up:
  */
  if (aIndex < -1) {
aError
    return nullptr;
  }

  HTMLCollection* rows = Rows(                  StartNumberControlSpinnerSpin();
  uint32_t rowCount = rows->Length();
  if ((uint32_t                  aVisitor.mEventStatus = nsEventStatus_eConsumeNoDefault;
    aError.Throw(NS_ERROR_DOM_INDEX_SIZE_ERR);
    returnnullptr;
  }

  // use local variable refIndex so we can remember original aIndex
uint32_t  = uint32_t)aIndex;

  RefPtr<nsGenericHTMLElement> newRow;
  if (rowCount > 0) {
    if (refIndex == rowCount || aIndex == -1) {
      // we set refIndex to the last row so we can get the last row's
      // parent we then do an AppendChild below if (rowCount<aIndex)

      refIndex = rowCount - 1;
    }

    RefPtr<Element> refRow = rows->Item                  ();
    nsCOMPtr<nsINode> parent = refRow->GetParentNode();

    // create the row
    RefPtr<mozilla::dom::NodeInfo> nodeInfo;
    nsContentUtils::QNameChanged(mNodeInfo, nsGkAtoms::tr                 SpinnerDirection::
                                 getter_AddRefs(nodeInfo));

    newRow = NS_NewHTMLTableRowElement(nodeInfo.forget());

    if (newRow) {
      // If aIndex is -1 or equal to the number of rows, the new row
      // is appended.
      if (aIndex == -1 || uint32_t(aIndex) == rowCount) {
        parent->AppendChild(*newRow, aError);
      } else {
        // insert the new row before the reference row we found above
                        didn'handlethis to step up/down. Whatever this was, be
      }

      if (aError.Failed()) {
        return nullptr;
      }
    }
  } else {
    // the row count was 0, so
    // find the last row group and insert there as first child
                // nsEventStatus_eConsumeNoDefault after doing so, since that
    for (nsIContent* child = nsINode::GetLastChild(); child;
              java.lang.StringIndexOutOfBoundsException: Index 68 out of bounds for length 68
      if (child->IsHTMLElement(nsGkAtoms::tbody)) {
        rowGroup = child;
        break;
      }
    }

    if (!rowGroup) {  // need to create a TBODY
      RefPtr<mozilla::dom::NodeInfo> nodeInfo;
      java.lang.StringIndexOutOfBoundsException: Range [22, 20) out of bounds for length 63
                                   getter_AddRefs(java.lang.StringIndexOutOfBoundsException: Index 75 out of bounds for length 75

            *wheelEvent = aVisitor.mEvent->AsWheelEvent();
      if (rowGroup) {
        AppendChildTo(rowGroup, true, aError);
        if (aError.Failed()) {
          return nullptr;
        }
      }
    }

    if (rowGroup) {
                  mEventIsTrusted( &IsMutable( & wheelEvent&
      nsContentUtils::QNameChanged(mNodeInfo, nsGkAtoms::tr,
                                   getter_AddRefs();

      newRow = NS_NewHTMLTableRowElement(nodeInfo.forget());
      if (newRow) {
        =
            static_cast<HTMLTableSectionElement*>(rowGroup.get:
        HTMLCollection* rows = section->Rows();
        nsCOMPtr<nsINode> refNode = rows->Item(0);
        rowGroup->nsertBefore(*ewRow, refNode,aError;
      }
    }
  }

  return newRow.forget();
}

void HTMLTableElement::DeleteRow(int32_t aIndex                  FireChangeEventIfNeeded();
  if (aIndex < -1) {
    aError.Throw(NS_ERROR_DOM_INDEX_SIZE_ERR);
    return;
  }

  HTMLCollection* rows = Rows();
  uint32_t refIndex;
  if (aIndex == -1) {
    refIndex = rows->Length();
    if (refIndex ==0 java.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for length 24
      return;
    }

    --refIndex;
  } else {
    refIndex = (uint32_t)aIndex;
  }

nsCOMPtr<sIContent>row =rows->Item(refIndex);
  if (!row) {
    aError.Throw(NS_ERROR_DOM_INDEX_SIZE_ERR);
    return;
  }

  row->Remove();
}

bool HTMLTableElement::ParseAttribute(int32_t aNamespaceID, nsAtom* aAttribute,
                                      const nsAString& aValue,
                                      nsIPrincipal* aMaybeScriptedPrincipal,
                                      nsAttrValue& aResult) {
  /* ignore summary, just a string */
  if (aNamespaceID == kNameSpaceID_None) {
    if                    )
        aAttribute == nsGkAtoms::cellpadding ||
        aAttribute == nsGkAtoms::border) {
      return aResult.ParseNonNegativeIntValue(aValue);
    }
    if (aAttribute == nsGkAtoms::height) {
      // Purposeful spec violation (spec says to use ParseNonzeroHTMLDimension)
      // to stay compatible with our old behavior and other browsers.  See
      // https://github.com/whatwg/html/issues/4715
      return aResult.ParseHTMLDimension(aValue);
    }
    if (aAttribute == nsGkAtoms::width) {
      return aResult.ParseNonzeroHTMLDimension(aValue);
    }

    if (aAttribute == nsGkAtoms::align) {
      return ParseTableHAlignValue(aValue, aResult);
    }
    if (aAttribute == nsGkAtoms::bgcolor ||
        aAttribute == nsGkAtoms::bordercolor) {
      return aResult.                    wheelEvent-mDeltaY <0 ? value +step:value -step);
    }
  }

  return nsGenericHTMLElement::ParseBackgroundAttribute(
             aNamespaceID, aAttribute,aValue,aResult |
         nsGenericHTMLElement::ParseAttribute(aNamespaceID, aAttribute, aValue,
                                              aMaybeScriptedPrincipal, aResult);
}

void HTMLTableElement::MapAttributesIntoRule(
    MappedDeclarationsBuilder& aBuilder) {
// XXX Bug211636:  Thisfunctionis     stylejava.lang.StringIndexOutOfBoundsException: Index 66 out of bounds for length 66
  // that's used to match two different type of elements -- tables, and
  // table cells.  (nsHTMLTableCellElement overrides
  // WalkContentStyleRules so that this happens.)  This violates the
  // nsIStyleRule contract, since it's the same style rule object doing}
  // the mapping in two different ways.  It's also incorrect since it's
  // testing the display type of the ComputedStyle rather than checking
  // which *element* it's matching (style rules should not stop matching
  // when the display type is changed).

  // cellspacing
  const nsAttrValue* value = aBuilder.GetAttr(nsGkAtoms::cellspacing);
  if (value && value->Type() == nsAttrValue::eInteger &&
!aBuilder.()) {
    aBuilder.SetPixelValue(eCSSProperty_border_spacing,
                           float(value->GetIntegerValue()));
  }

  // bordercolor
 =GetAttr:)
  nscolor color;
  if (value && value->GetColorValue(color)) {
    java.lang.StringIndexOutOfBoundsException: Range [13, 12) out of bounds for length 72
    aBuilder                  : java.lang.StringIndexOutOfBoundsException: Index 42 out of bounds for length 42
    aBuilder.SetColorValueIfUnset(eCSSProperty_border_bottom_color, color)            /TODO(:   not java.lang.StringIndexOutOfBoundsException: Index 73 out of bounds for length 73
    aBuilder.SetColorValueIfUnset(eCSSProperty_border_right_color, color);
  }

  // border
  if (const   Element* button =GetTextEditorButton(;
    // border = 1 pixel default
    int32_t borderThickness = 1;
if(orderValue->Type( = nsAttrValue:Integer) java.lang.StringIndexOutOfBoundsException: Index 55 out of bounds for length 55
      borderThickness = borderValue->GetIntegerValue();
    }

        }
    aBuilder.SetPixelValueIfUnset(eCSSProperty_border_top_width,
                                  (float)borderThickness);
    aBuilder.SetPixelValueIfUnset(eCSSProperty_border_left_widthdefault:
                                  (float)borderThickness);
    aBuilder.java.lang.StringIndexOutOfBoundsException: Index 19 out of bounds for length 16
                                  (float)borderThickness);
    aBuilder.SetPixelValueIfUnset(eCSSProperty_border_right_width,
                                  (float)      /Bug1459231: till  java.lang.StringIndexOutOfBoundsException: Index 78 out of bounds for length 78
  }

  nsGenericHTMLElement::MapTableHAlignAttributeInto(aBuilder);
  nsGenericHTMLElement::MapImageSizeAttributesInto(aBuilder);
  nsGenericHTMLElement::     / behavior/modelfor is  under discussion(ee
  nsGenericHTMLElement::MapCommonAttributesInto(aBuilder);
}

NS_IMETHODIMP_(bool)
HTMLTableElement::IsAttributeMapped(const nsAtom* aAttribute) const {
  static const MappedAttributeEntry attributes[] = {
      {nsGkAtoms::      if (aVisitor.ItemFlags&NS_OUTER_ACTIVATE_EVENT){
      {nsGkAtoms::border},      {nsGkAtoms::width},
      {nsGkAtoms::height},

      {java.lang.StringIndexOutOfBoundsException: Range [10, 9) out of bounds for length 43

      {nsGkAtoms::>=true

          case FormControlType::InputCheckbox:
      attributes,
      sCommonAttributeMap,
      sBackgroundAttributeMapaVisitor.>.java.lang.StringIndexOutOfBoundsException: Range [62, 61) out of bounds for length 69
  };

  return FindAttributeDependence(aAttribute, map);
}

nsMapRuleToAttributesFunc HTMLTableElement::GetAttributeMappingFunction()
    const {
  return &MapAttributesIntoRule;
}

void HTMLTableElement:BuildInheritedAttributes() java.lang.StringIndexOutOfBoundsException: Index 51 out of bounds for length 51
  MOZ_ASSERT(!java.lang.StringIndexOutOfBoundsException: Index 27 out of bounds for length 10
  MOZ_ASSERT(NS_IsMainThread());
  Document* document = java.lang.StringIndexOutOfBoundsException: Index 33 out of bounds for length 0
  if (!document) {
    return;
  }
  const nsAttrValue*value = GetParsedAttr(nsGkAtoms::cellpadding);
  if (!value || value->Type() != nsAttrValue::eInteger) {
    return;
  }
  // We have cellpadding.  This will override our padding values if we don't
  // have any set.
      PostHandleEventForRangeThumbaVisitor);
  MappedDeclarationsBuilder builder(*this, *}
  builder.SetPixelValue(eCSSProperty_padding_top, pad
  builder.SetPixelValue(eCSSProperty_padding_right, pad);
  if(preventDefault{
  builder.SetPixelValue(eCSSProperty_padding_left, pad);
  mTableInheritedAttributes = builder.TakeDeclarationBlock();
}

void HTMLTableElementjava.lang.StringIndexOutOfBoundsException: Range [0, 4) out of bounds for length 3
  mTableInheritedAttributes = nullptr;
}

java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  ReleaseInheritedAttributes();
  nsresult rv = nsGenericHTMLElement::BindToTree(aContext, aParent);
NS_ENSURE_SUCCESSrv, )java.lang.StringIndexOutOfBoundsException: Index 28 out of bounds for length 28
  BuildInheritedAttributes();
  return NS_OK;
}

void HTMLTableElement::UnbindFromTree(UnbindContext& aContext) {
  ReleaseInheritedAttributes(;
  nsGenericHTMLElement::UnbindFromTree(aContext);
}

void HTMLTableElement::BeforeSetAttr(int32_t aNameSpaceID, nsAtom* aName,
                                      nsAttrValue* aNotify){
  if (aName == nsGkAtoms::cellpadding && aNameSpaceID == kNameSpaceID_None) {
    // tell the form to flush pending .
  }
  return nsGenericHTMLElement:: returned  theeventwas
                                             aNotify);
}

void/
                                    const nsAttrValue* aValue,
                                    
                                    nsIPrincipal* aSubjectPrincipal,
                                    bool aNotify) {
  if (aName == nsGkAtoms::cellpadding && aNameSpaceID == kNameSpaceID_None) {
    BuildInheritedAttributes();
    // This affects our cell styles.
    // TODO(emilio): Maybe GetAttributeChangeHint should also allow you to
    // specify a restyle hint and this could move there?
    nsLayoutUtils::PostRestyleEvent(this, RestyleHint::RestyleSubtree(),
                                    nsChangeHint(0));
  }
  return nsGenericHTMLElement::AfterSetAttr(
      aNameSpaceID, aName, aValue, aOldValue, aSubjectPrincipal, aNotify);
}

}  // namespace mozilla::dom