/* * Copyright (c) 2024-2025, Jelle Raaijmakers * * SPDX-License-Identifier: BSD-2-Clause */ #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include namespace Web::Editing { // https://w3c.github.io/editing/docs/execCommand/#active-range GC::Ptr active_range(DOM::Document const& document) { // The active range is the range of the selection given by calling getSelection() on the context object. (Thus the // active range may be null.) auto selection = document.get_selection(); if (!selection) return {}; return selection->range(); } // https://w3c.github.io/editing/docs/execCommand/#alignment-value JustifyAlignment alignment_value_of_node(GC::Ptr node) { // 1. While node is neither null nor an Element, or it is an Element but its "display" property has resolved value // "inline" or "none", set node to its parent. auto is_display_inline_or_none = [](GC::Ref node) { auto display = resolved_display(node); if (!display.has_value()) return false; return (display.value().is_inline_outside() && display.value().is_flow_inside()) || display.value().is_none(); }; while ((node && !is(node.ptr())) || (is(node.ptr()) && is_display_inline_or_none(*node))) node = node->parent(); // 2. If node is not an Element, return "left". if (!is(node.ptr())) return JustifyAlignment::Left; GC::Ref element = static_cast(*node); // 3. If node's "text-align" property has resolved value "start", return "left" if the directionality of node is // "ltr", "right" if it is "rtl". auto text_align_value = resolved_keyword(*node, CSS::PropertyID::TextAlign); if (!text_align_value.has_value()) return JustifyAlignment::Left; if (text_align_value.value() == CSS::Keyword::Start) return element->directionality() == DOM::Element::Directionality::Ltr ? JustifyAlignment::Left : JustifyAlignment::Right; // 4. If node's "text-align" property has resolved value "end", return "right" if the directionality of node is // "ltr", "left" if it is "rtl". if (text_align_value.value() == CSS::Keyword::End) return element->directionality() == DOM::Element::Directionality::Ltr ? JustifyAlignment::Right : JustifyAlignment::Left; // 5. If node's "text-align" property has resolved value "center", "justify", "left", or "right", return that value. switch (text_align_value.value()) { case CSS::Keyword::Center: return JustifyAlignment::Center; case CSS::Keyword::Justify: return JustifyAlignment::Justify; case CSS::Keyword::Left: return JustifyAlignment::Left; case CSS::Keyword::Right: return JustifyAlignment::Right; default: // 6. Return "left". return JustifyAlignment::Left; } } // https://w3c.github.io/editing/docs/execCommand/#autolink void autolink(DOM::BoundaryPoint point) { // 1. While (node, end offset)'s previous equivalent point is not null, set it to its previous equivalent point. while (true) { auto previous_point = previous_equivalent_point(point); if (!previous_point.has_value()) break; point = previous_point.release_value(); } // 2. If node is not a Text node, or has an a ancestor, do nothing and abort these steps. if (!is(*point.node) || point.node->first_ancestor_of_type()) return; // FIXME: 3. Let search be the largest substring of node's data whose end is end offset and that contains no space // characters. // FIXME: 4. If some substring of search is an autolinkable URL: Utf16String href; if (false) { // FIXME: 1. While there is no substring of node's data ending at end offset that is an autolinkable URL, decrement end // offset. // FIXME: 2. Let start offset be the start index of the longest substring of node's data that is an autolinkable URL // ending at end offset. // FIXME: 3. Let href be the substring of node's data starting at start offset and ending at end offset. } // FIXME: 5. Otherwise, if some substring of search is a valid e-mail address: else if (false) { // FIXME: 1. While there is no substring of node's data ending at end offset that is a valid e-mail address, decrement // end offset. // FIXME: 2. Let start offset be the start index of the longest substring of node's data that is a valid e-mail address // ending at end offset. // FIXME: 3. Let href be "mailto:" concatenated with the substring of node's data starting at start offset and ending // at end offset. } // 6. Otherwise, do nothing and abort these steps. else { return; } // 7. Let original range be the active range. auto& document = point.node->document(); auto original_range = active_range(document); // FIXME: 8. Create a new range with start (node, start offset) and end (node, end offset), and set the context object's // selection's range to it. // 9. Take the action for "createLink", with value equal to href. take_the_action_for_command(document, CommandNames::createLink, href); // 10. Set the context object's selection's range to original range. if (original_range) document.get_selection()->add_range(*original_range); } // https://w3c.github.io/editing/docs/execCommand/#block-extend GC::Ref block_extend_a_range(GC::Ref range) { // 1. Let start node, start offset, end node, and end offset be the start and end nodes and offsets of range. GC::Ptr start_node = range->start_container(); auto start_offset = range->start_offset(); GC::Ptr end_node = range->end_container(); auto end_offset = range->end_offset(); // 2. If some inclusive ancestor of start node is an li, set start offset to the index of the last such li in tree // order, and set start node to that li's parent. start_node->for_each_inclusive_ancestor([&](GC::Ref ancestor) { if (is(*ancestor)) { start_offset = ancestor->index(); start_node = ancestor->parent(); return IterationDecision::Break; } return IterationDecision::Continue; }); // 3. If (start node, start offset) is not a block start point, repeat the following steps: if (!is_block_start_point({ *start_node, start_offset })) { do { // 1. If start offset is zero, set it to start node's index, then set start node to its parent. if (start_offset == 0) { start_offset = start_node->index(); start_node = start_node->parent(); } // 2. Otherwise, subtract one from start offset. else { --start_offset; } // 3. If (start node, start offset) is a block boundary point, break from this loop. } while (!is_block_boundary_point({ *start_node, start_offset })); } // 4. While start offset is zero and start node's parent is not null, set start offset to start node's index, then // set start node to its parent. while (start_offset == 0 && start_node->parent()) { start_offset = start_node->index(); start_node = start_node->parent(); } // 5. If some inclusive ancestor of end node is an li, set end offset to one plus the index of the last such li in // tree order, and set end node to that li's parent. end_node->for_each_inclusive_ancestor([&](GC::Ref ancestor) { if (is(*ancestor)) { end_offset = ancestor->index() + 1; end_node = ancestor->parent(); return IterationDecision::Break; } return IterationDecision::Continue; }); // 6. If (end node, end offset) is not a block end point, repeat the following steps: if (!is_block_end_point({ *end_node, end_offset })) { do { // 1. If end offset is end node's length, set it to one plus end node's index, then set end node to its // parent. if (end_offset == end_node->length()) { end_offset = end_node->index() + 1; end_node = end_node->parent(); } // 2. Otherwise, add one to end offset. else { ++end_offset; } // 3. If (end node, end offset) is a block boundary point, break from this loop. } while (!is_block_boundary_point({ *end_node, end_offset })); } // 7. While end offset is end node's length and end node's parent is not null, set end offset to one plus end node's // index, then set end node to its parent. while (end_offset == end_node->length() && end_node->parent()) { end_offset = end_node->index() + 1; end_node = end_node->parent(); } // 8. Let new range be a new range whose start and end nodes and offsets are start node, start offset, end node, and // end offset. auto new_range = DOM::Range::create(*start_node, start_offset, *end_node, end_offset); // 9. Return new range. return new_range; } // https://w3c.github.io/editing/docs/execCommand/#block-node-of GC::Ptr block_node_of_node(GC::Ref input_node) { // 1. While node is an inline node, set node to its parent. GC::Ptr node = input_node; while (node && is_inline_node(*node)) node = node->parent(); // 2. Return node. return node; } // https://w3c.github.io/editing/docs/execCommand/#canonical-space-sequence Utf16String canonical_space_sequence(size_t length, bool non_breaking_start, bool non_breaking_end) { auto n = length; // 1. If n is zero, return the empty string. if (n == 0) return {}; // 2. If n is one and both non-breaking start and non-breaking end are false, return a single // space (U+0020). if (n == 1 && !non_breaking_start && !non_breaking_end) return " "_utf16; // 3. If n is one, return a single non-breaking space (U+00A0). if (n == 1) return "\u00A0"_utf16; // 4. Let buffer be the empty string. StringBuilder buffer { StringBuilder::Mode::UTF16 }; // 5. If non-breaking start is true, let repeated pair be U+00A0 U+0020. Otherwise, let it be // U+0020 U+00A0. auto repeated_pair = non_breaking_start ? "\u00A0 "sv : " \u00A0"sv; // 6. While n is greater than three, append repeated pair to buffer and subtract two from n. // AD-HOC: Other browsers seem to fit in as many repeated pairs until the remaining length is <= 2. while (n > 2) { buffer.append(repeated_pair); n -= 2; } // 7. If n is three, append a three-code unit string to buffer depending on non-breaking start // and non-breaking end: // // non-breaking start and non-breaking end false // U+0020 U+00A0 U+0020 // // non-breaking start true, non-breaking end false // U+00A0 U+00A0 U+0020 // // non-breaking start false, non-breaking end true // U+0020 U+00A0 U+00A0 // // non-breaking start and non-breaking end both true // U+00A0 U+0020 U+00A0 // 8. Otherwise, append a two-code unit string to buffer depending on non-breaking start and // non-breaking end: // // non-breaking start and non-breaking end false // non-breaking start true, non-breaking end false // U+00A0 U+0020 // // non-breaking start false, non-breaking end true // U+0020 U+00A0 // // non-breaking start and non-breaking end both true // U+00A0 U+00A0 // AD-HOC: Other browsers seem to ignore the above and deal differently with padding the remainder; the first // remaining position is filled with the first character from repeated pair. if (n > 0) { buffer.append(repeated_pair.substring_view(0, 1) == " "sv ? " "sv : "\u00A0"sv); --n; } // AD-HOC: Then, the final position is set depending on the value of non-breaking end. if (n > 0) buffer.append(non_breaking_end ? "\u00A0"sv : " "sv); // 9. Return buffer. return buffer.to_utf16_string(); } // https://w3c.github.io/editing/docs/execCommand/#canonicalize-whitespace void canonicalize_whitespace(DOM::BoundaryPoint boundary, bool fix_collapsed_space) { auto node = boundary.node; auto offset = boundary.offset; // 1. If node is neither editable nor an editing host, abort these steps. if (!node->is_editable_or_editing_host()) return; // 2. Let start node equal node and let start offset equal offset. auto start_node = node; auto start_offset = offset; // 3. Repeat the following steps: while (true) { // 1. If start node has a child in the same editing host with index start offset minus one, // set start node to that child, then set start offset to start node's length. auto* offset_minus_one_child = start_node->child_at_index(start_offset - 1); if (offset_minus_one_child && is_in_same_editing_host(*start_node, *offset_minus_one_child)) { start_node = *offset_minus_one_child; start_offset = start_node->length(); continue; } // 2. Otherwise, if start offset is zero and start node does not follow a line break and // start node's parent is in the same editing host, set start offset to start node's // index, then set start node to its parent. if (start_offset == 0 && !follows_a_line_break(start_node) && is_in_same_editing_host(*start_node, *start_node->parent())) { start_offset = start_node->index(); start_node = *start_node->parent(); continue; } // 3. Otherwise, if start node is a Text node and its parent's resolved value for // "white-space" is neither "pre" nor "pre-wrap" and start offset is not zero and the // (start offset − 1)st code unit of start node's data is a space (0x0020) or // non-breaking space (0x00A0), subtract one from start offset. // AD-HOC: Use the white-space-collapse longhand instead of "white-space" shorthand: https://github.com/w3c/editing/issues/486. if (is(*start_node) && start_offset != 0) { auto parent_white_space_collapse = resolved_keyword(*start_node->parent(), CSS::PropertyID::WhiteSpaceCollapse); auto start_node_data = start_node->text_content().release_value(); auto offset_minus_one_code_unit = start_node_data.code_unit_at(start_offset - 1); if (parent_white_space_collapse != CSS::Keyword::Preserve && (offset_minus_one_code_unit == 0x20 || offset_minus_one_code_unit == 0xA0)) { --start_offset; continue; } } // 4. Otherwise, break from this loop. break; } // 4. Let end node equal start node and end offset equal start offset. auto end_node = start_node; auto end_offset = start_offset; // 5. Let length equal zero. auto length = 0; // 6. Let collapse spaces be true if start offset is zero and start node follows a line break, // otherwise false. auto collapse_spaces = start_offset == 0 && follows_a_line_break(start_node); // 7. Repeat the following steps: while (true) { // 1. If end node has a child in the same editing host with index end offset, set end node // to that child, then set end offset to zero. auto* offset_child = end_node->child_at_index(end_offset); if (offset_child && is_in_same_editing_host(*end_node, *offset_child)) { end_node = *offset_child; end_offset = 0; continue; } // 2. Otherwise, if end offset is end node's length and end node does not precede a line // break and end node's parent is in the same editing host, set end offset to one plus // end node's index, then set end node to its parent. if (end_offset == end_node->length() && !precedes_a_line_break(end_node) && is_in_same_editing_host(*end_node, *end_node->parent())) { end_offset = end_node->index() + 1; end_node = *end_node->parent(); continue; } // 3. Otherwise, if end node is a Text node and its parent's resolved value for // "white-space" is neither "pre" nor "pre-wrap" and end offset is not end node's length // and the end offsetth code unit of end node's data is a space (0x0020) or non-breaking // space (0x00A0): // AD-HOC: Use the white-space-collapse longhand instead of "white-space" shorthand: https://github.com/w3c/editing/issues/486. if (is(*end_node) && end_offset != end_node->length()) { auto parent_white_space_collapse = resolved_keyword(*end_node->parent(), CSS::PropertyID::WhiteSpaceCollapse); auto end_node_data = end_node->text_content().release_value(); auto offset_code_unit = end_node_data.code_unit_at(end_offset); if (parent_white_space_collapse != CSS::Keyword::Preserve && (offset_code_unit == 0x20 || offset_code_unit == 0xA0)) { // 1. If fix collapsed space is true, and collapse spaces is true, and the end offsetth // code unit of end node's data is a space (0x0020): call deleteData(end offset, 1) // on end node, then continue this loop from the beginning. if (fix_collapsed_space && collapse_spaces && offset_code_unit == 0x20) { MUST(static_cast(*end_node).delete_data(end_offset, 1)); continue; } // 2. Set collapse spaces to true if the end offsetth code unit of end node's data is a // space (0x0020), false otherwise. collapse_spaces = offset_code_unit == 0x20; // 3. Add one to end offset. ++end_offset; // 4. Add one to length. ++length; // NOTE: We continue the loop here since we matched every condition from step 7.3 continue; } } // 4. Otherwise, break from this loop. break; } // 8. If fix collapsed space is true, then while (start node, start offset) is before (end node, // end offset): if (fix_collapsed_space) { while (true) { auto relative_position = DOM::position_of_boundary_point_relative_to_other_boundary_point({ *start_node, start_offset }, { *end_node, end_offset }); if (relative_position != DOM::RelativeBoundaryPointPosition::Before) break; // 1. If end node has a child in the same editing host with index end offset − 1, set end // node to that child, then set end offset to end node's length. auto offset_minus_one_child = end_node->child_at_index(end_offset - 1); if (offset_minus_one_child && is_in_same_editing_host(end_node, *offset_minus_one_child)) { end_node = *offset_minus_one_child; end_offset = end_node->length(); continue; } // 2. Otherwise, if end offset is zero and end node's parent is in the same editing host, // set end offset to end node's index, then set end node to its parent. if (end_offset == 0 && is_in_same_editing_host(end_node, *end_node->parent())) { end_offset = end_node->index(); end_node = *end_node->parent(); continue; } // 3. Otherwise, if end node is a Text node and its parent's resolved value for // "white-space" is neither "pre" nor "pre-wrap" and end offset is end node's length and // the last code unit of end node's data is a space (0x0020) and end node precedes a line // break: // AD-HOC: Use the white-space-collapse longhand instead of "white-space" shorthand: https://github.com/w3c/editing/issues/486. if (is(*end_node) && end_offset == end_node->length() && precedes_a_line_break(end_node)) { auto parent_white_space_collapse = resolved_keyword(*end_node->parent(), CSS::PropertyID::WhiteSpaceCollapse); if (parent_white_space_collapse != CSS::Keyword::Preserve && end_node->text_content()->ends_with(' ')) { // 1. Subtract one from end offset. --end_offset; // 2. Subtract one from length. --length; // 3. Call deleteData(end offset, 1) on end node. MUST(static_cast(*end_node).delete_data(end_offset, 1)); // NOTE: We continue the loop here since we matched every condition from step 8.3 continue; } } // 4. Otherwise, break from this loop. break; } } // 9. Let replacement whitespace be the canonical space sequence of length length. non-breaking // start is true if start offset is zero and start node follows a line break, and false // otherwise. non-breaking end is true if end offset is end node's length and end node // precedes a line break, and false otherwise. // AD-HOC: Other browsers' behavior here is to set non_breaking_start to true if length > 1, so we add that // condition as well. auto replacement_whitespace = canonical_space_sequence( length, (start_offset == 0 && follows_a_line_break(start_node)) || length > 1, end_offset == end_node->length() && precedes_a_line_break(end_node)); auto replacement_whitespace_view = replacement_whitespace.utf16_view(); // 10. While (start node, start offset) is before (end node, end offset): while (true) { auto relative_position = DOM::position_of_boundary_point_relative_to_other_boundary_point({ start_node, start_offset }, { end_node, end_offset }); if (relative_position != DOM::RelativeBoundaryPointPosition::Before) break; // 1. If start node has a child with index start offset, set start node to that child, then // set start offset to zero. if (start_node->child_at_index(start_offset)) { start_node = *start_node->child_at_index(start_offset); start_offset = 0; } // 2. Otherwise, if start node is not a Text node or if start offset is start node's length, // set start offset to one plus start node's index, then set start node to its parent. else if (!is(*start_node) || start_offset == start_node->length()) { start_offset = start_node->index() + 1; start_node = *start_node->parent(); } // 3. Otherwise: else { // 1. Remove the first code unit from replacement whitespace, and let element be that // code unit. auto element = replacement_whitespace_view.code_unit_at(0); replacement_whitespace_view = replacement_whitespace_view.substring_view(1); // 2. If element is not the same as the start offsetth code unit of start node's data: auto start_node_data = start_node->text_content().release_value(); auto start_node_code_unit = start_node_data.code_unit_at(start_offset); if (element != start_node_code_unit) { // 1. Call insertData(start offset, element) on start node. auto& start_node_character_data = static_cast(*start_node); MUST(start_node_character_data.insert_data(start_offset, Utf16String::from_code_point(element))); // 2. Call deleteData(start offset + 1, 1) on start node. MUST(start_node_character_data.delete_data(start_offset + 1, 1)); } // 3. Add one to start offset. ++start_offset; } } } // https://w3c.github.io/editing/docs/execCommand/#clear-the-value Vector> clear_the_value(FlyString const& command, GC::Ref element) { // 1. Let command be the current command. // 2. If element is not editable, return the empty list. if (!element->is_editable()) return {}; // 3. If element's specified command value for command is null, return the empty list. if (!specified_command_value(element, command).has_value()) return {}; // 4. If element is a simple modifiable element: if (is_simple_modifiable_element(element)) { // 1. Let children be the children of element. Vector> children; element->for_each_child([&children](DOM::Node& child) { children.append(child); return IterationDecision::Continue; }); // 2. For each child in children, insert child into element's parent immediately before element, preserving // ranges. auto element_index = element->index(); for (auto child : children) move_node_preserving_ranges(child, *element->parent(), element_index++); // 3. Remove element from its parent. element->remove(); // 4. Return children. return children; } // 5. If command is "strikethrough", and element has a style attribute that sets "text-decoration" to some value // containing "line-through", delete "line-through" from the value. auto remove_text_decoration_value = [&element](CSS::Keyword keyword_to_delete) { auto inline_style = element->inline_style(); if (!inline_style) return; auto style_value = inline_style->get_property_style_value(CSS::PropertyID::TextDecoration); if (!style_value) return; VERIFY(style_value->is_value_list()); auto const& value_list = style_value->as_value_list(); auto& old_values = value_list.values(); auto new_values = old_values; auto was_removed = new_values.remove_all_matching([&](ValueComparingNonnullRefPtr const& value) { return value->is_keyword() && value->as_keyword().keyword() == keyword_to_delete; }); if (!was_removed) return; if (new_values.is_empty()) { MUST(inline_style->remove_property(CSS::PropertyID::TextDecoration)); return; } auto new_style_value = CSS::StyleValueList::create(move(new_values), value_list.separator()); MUST(inline_style->set_property( CSS::PropertyID::TextDecoration, new_style_value->to_string(CSS::SerializationMode::Normal), {})); }; if (command == CommandNames::strikethrough) remove_text_decoration_value(CSS::Keyword::LineThrough); // 6. If command is "underline", and element has a style attribute that sets "text-decoration" to some value // containing "underline", delete "underline" from the value. if (command == CommandNames::underline) remove_text_decoration_value(CSS::Keyword::Underline); // 7. If the relevant CSS property for command is not null, unset that property of element. auto command_definition = find_command_definition(command); if (command_definition->relevant_css_property.has_value()) { auto property_to_remove = command_definition->relevant_css_property.value(); if (auto inline_style = element->inline_style()) MUST(inline_style->remove_property(property_to_remove)); } // 8. If element is a font element: if (is(*element)) { // 1. If command is "foreColor", unset element's color attribute, if set. if (command == CommandNames::foreColor) element->remove_attribute(HTML::AttributeNames::color); // 2. If command is "fontName", unset element's face attribute, if set. if (command == CommandNames::fontName) element->remove_attribute(HTML::AttributeNames::face); // 3. If command is "fontSize", unset element's size attribute, if set. if (command == CommandNames::fontSize) element->remove_attribute(HTML::AttributeNames::size); } // 9. If element is an a element and command is "createLink" or "unlink", unset the href property of element. if (is(*element) && command.is_one_of(CommandNames::createLink, CommandNames::unlink)) element->remove_attribute(HTML::AttributeNames::href); // 10. If element's specified command value for command is null, return the empty list. if (!specified_command_value(element, command).has_value()) return {}; // 11. Set the tag name of element to "span", and return the one-node list consisting of the result. return { set_the_tag_name(element, HTML::TagNames::span) }; } // https://w3c.github.io/editing/docs/execCommand/#delete-the-selection void delete_the_selection(Selection& selection, bool block_merging, bool strip_wrappers, Selection::Direction direction) { auto& document = *selection.document(); // 1. If the active range is null, abort these steps and do nothing. // NOTE: The selection is collapsed often in this algorithm, so we shouldn't store the active range in a variable. if (!active_range(document)) return; // 2. Canonicalize whitespace at the active range's start. canonicalize_whitespace(active_range(document)->start()); // 3. Canonicalize whitespace at the active range's end. canonicalize_whitespace(active_range(document)->end()); // 4. Let (start node, start offset) be the last equivalent point for the active range's start. auto start = last_equivalent_point(active_range(document)->start()); // 5. Let (end node, end offset) be the first equivalent point for the active range's end. auto end = first_equivalent_point(active_range(document)->end()); // 6. If (end node, end offset) is not after (start node, start offset): auto relative_position = DOM::position_of_boundary_point_relative_to_other_boundary_point(end, start); if (relative_position != DOM::RelativeBoundaryPointPosition::After) { // 1. If direction is "forward", call collapseToStart() on the context object's selection. if (direction == Selection::Direction::Forwards) { MUST(selection.collapse_to_start()); } // 2. Otherwise, call collapseToEnd() on the context object's selection. else { MUST(selection.collapse_to_end()); } // 3. Abort these steps. return; } // 7. If start node is a Text node and start offset is 0, set start offset to the index of start node, then set // start node to its parent. if (is(*start.node) && start.offset == 0 && start.node->parent()) { start = { *start.node->parent(), static_cast(start.node->index()), }; } // 8. If end node is a Text node and end offset is its length, set end offset to one plus the index of end node, // then set end node to its parent. if (is(*end.node) && end.offset == end.node->length() && end.node->parent()) { end = { *end.node->parent(), static_cast(end.node->index() + 1), }; } // 9. Call collapse(start node, start offset) on the context object's selection. MUST(selection.collapse(start.node, start.offset)); // 10. Call extend(end node, end offset) on the context object's selection. MUST(selection.extend(end.node, end.offset)); // 12. Let start block be the active range's start node. GC::Ptr start_block = active_range(document)->start_container(); // 13. While start block's parent is in the same editing host and start block is an inline node, set start block to // its parent. while (start_block->parent() && is_in_same_editing_host(*start_block->parent(), *start_block) && is_inline_node(*start_block)) start_block = *start_block->parent(); // 14. If start block is neither a block node nor an editing host, or "span" is not an allowed child of start block, // or start block is a td or th, set start block to null. if ((!is_block_node(*start_block) && !start_block->is_editing_host()) || !is_allowed_child_of_node(HTML::TagNames::span, GC::Ref { *start_block }) || is(*start_block)) start_block = {}; // 15. Let end block be the active range's end node. GC::Ptr end_block = active_range(document)->end_container(); // 16. While end block's parent is in the same editing host and end block is an inline node, set end block to its // parent. while (end_block->parent() && is_in_same_editing_host(*end_block->parent(), *end_block) && is_inline_node(*end_block)) end_block = end_block->parent(); // 17. If end block is neither a block node nor an editing host, or "span" is not an allowed child of end block, or // end block is a td or th, set end block to null. if ((!is_block_node(*end_block) && !end_block->is_editing_host()) || !is_allowed_child_of_node(HTML::TagNames::span, GC::Ref { *end_block }) || is(*end_block)) end_block = {}; // 19. Record current states and values, and let overrides be the result. auto overrides = record_current_states_and_values(document); // 21. If start node and end node are the same, and start node is an editable Text node: if (start.node == end.node && is(*start.node) && start.node->is_editable()) { // 1. Call deleteData(start offset, end offset − start offset) on start node. MUST(static_cast(*start.node).delete_data(start.offset, end.offset - start.offset)); // 2. Canonicalize whitespace at (start node, start offset), with fix collapsed space false. canonicalize_whitespace(start, false); // 3. If direction is "forward", call collapseToStart() on the context object's selection. if (direction == Selection::Direction::Forwards) { MUST(selection.collapse_to_start()); } // 4. Otherwise, call collapseToEnd() on the context object's selection. else { MUST(selection.collapse_to_end()); } // 5. Restore states and values from overrides. restore_states_and_values(document, overrides); // 6. Abort these steps. return; } // 22. If start node is an editable Text node, call deleteData() on it, with start offset as the first argument and // (length of start node − start offset) as the second argument. if (is(*start.node) && start.node->is_editable()) MUST(static_cast(*start.node).delete_data(start.offset, start.node->length() - start.offset)); // 23. Let node list be a list of nodes, initially empty. Vector> node_list; // 24. For each node contained in the active range, append node to node list if the last member of node list (if // any) is not an ancestor of node; node is editable; and node is not a thead, tbody, tfoot, tr, th, or td. active_range(document)->for_each_contained([&node_list](GC::Ref node) { if (!node_list.is_empty() && node_list.last()->is_ancestor_of(node)) return IterationDecision::Continue; if (!node->is_editable()) return IterationDecision::Continue; if (!is(*node) && !is(*node) && !is(*node)) node_list.append(node); return IterationDecision::Continue; }); // 25. For each node in node list: for (auto node : node_list) { // 1. Let parent be the parent of node. // NOTE: All nodes in node_list are descendants of common_ancestor and as such, always have a parent. GC::Ptr parent = *node->parent(); // 2. Remove node from parent. node->remove(); // 3. If the block node of parent has no visible children, and parent is editable or an editing host, call // createElement("br") on the context object and append the result as the last child of parent. auto block_node_of_parent = block_node_of_node(*parent); if (block_node_of_parent && !has_visible_children(*block_node_of_parent) && parent->is_editable_or_editing_host()) MUST(parent->append_child(MUST(DOM::create_element(document, HTML::TagNames::br, Namespace::HTML)))); // 4. If strip wrappers is true or parent is not an inclusive ancestor of start node, while parent is an // editable inline node with length 0, let grandparent be the parent of parent, then remove parent from // grandparent, then set parent to grandparent. if (strip_wrappers || !parent->is_inclusive_ancestor_of(start.node)) { while (parent->parent() && parent->is_editable() && is_inline_node(*parent) && parent->length() == 0) { auto grandparent = parent->parent(); parent->remove(); parent = grandparent; } } } // 26. If end node is an editable Text node, call deleteData(0, end offset) on it. if (end.node->is_editable() && is(*end.node)) MUST(static_cast(*end.node).delete_data(0, end.offset)); // 27. Canonicalize whitespace at the active range's start, with fix collapsed space false. canonicalize_whitespace(active_range(document)->start(), false); // 28. Canonicalize whitespace at the active range's end, with fix collapsed space false. canonicalize_whitespace(active_range(document)->end(), false); // 30. If block merging is false, or start block or end block is null, or start block is not in the same editing // host as end block, or start block and end block are the same: if (!block_merging || !start_block || !end_block || !is_in_same_editing_host(*start_block, *end_block) || start_block == end_block) { // 1. If direction is "forward", call collapseToStart() on the context object's selection. if (direction == Selection::Direction::Forwards) { MUST(selection.collapse_to_start()); } // 2. Otherwise, call collapseToEnd() on the context object's selection. else { MUST(selection.collapse_to_end()); } // 3. Restore states and values from overrides. restore_states_and_values(document, overrides); // 4. Abort these steps. return; } // 31. If start block has one child, which is a collapsed block prop, remove its child from it. if (start_block->child_count() == 1 && is_collapsed_block_prop(*start_block->first_child())) start_block->first_child()->remove(); // 32. If start block is an ancestor of end block: Vector values; if (start_block->is_ancestor_of(*end_block)) { // 1. Let reference node be end block. auto reference_node = end_block; // 2. While reference node is not a child of start block, set reference node to its parent. while (reference_node->parent() && reference_node->parent() != start_block.ptr()) reference_node = reference_node->parent(); // 3. Call collapse() on the context object's selection, with first argument start block and second argument the // index of reference node. MUST(selection.collapse(start_block, reference_node->index())); // 4. If end block has no children: if (!end_block->has_children()) { // 1. While end block is editable and is the only child of its parent and is not a child of start block, let // parent equal end block, then remove end block from parent, then set end block to parent. while (end_block->parent() && end_block->is_editable() && end_block->parent()->child_count() == 1 && end_block->parent() != start_block.ptr()) { // AD-HOC: Set end_block's parent instead of end_block itself. // See: https://github.com/w3c/editing/issues/473 auto parent = end_block->parent(); end_block->remove(); end_block = parent; } // 2. If end block is editable and is not an inline node, and its previousSibling and nextSibling are both // inline nodes, call createElement("br") on the context object and insert it into end block's parent // immediately after end block. if (end_block->is_editable() && !is_inline_node(*end_block) && end_block->previous_sibling() && end_block->next_sibling() && is_inline_node(*end_block->previous_sibling()) && is_inline_node(*end_block->next_sibling())) { auto br = MUST(DOM::create_element(document, HTML::TagNames::br, Namespace::HTML)); end_block->parent()->insert_before(br, end_block->next_sibling()); } // 3. If end block is editable, remove it from its parent. if (end_block->is_editable()) end_block->remove(); // 4. Restore states and values from overrides. restore_states_and_values(document, overrides); // 5. Abort these steps. return; } // 5. If end block's firstChild is not an inline node, restore states and values from record, then abort these // steps. if (!is_inline_node(*end_block->first_child())) { restore_states_and_values(document, overrides); return; } // 6. Let children be a list of nodes, initially empty. Vector> children; // 7. Append the first child of end block to children. children.append(*end_block->first_child()); // 8. While children's last member is not a br, and children's last member's nextSibling is an inline node, // append children's last member's nextSibling to children. while (!is(*children.last()) && children.last()->next_sibling()) { GC::Ref next_sibling = *children.last()->next_sibling(); if (!is_inline_node(next_sibling)) break; children.append(next_sibling); } // 9. Record the values of children, and let values be the result. values = record_the_values_of_nodes(document.heap(), children); // 10. While children's first member's parent is not start block, split the parent of children. while (children.first()->parent() != start_block) split_the_parent_of_nodes(children); // 11. If children's first member's previousSibling is an editable br, remove that br from its parent. if (is(children.first()->previous_sibling()) && children.first()->previous_sibling()->is_editable()) children.first()->previous_sibling()->remove(); } // 33. Otherwise, if start block is a descendant of end block: else if (start_block->is_descendant_of(*end_block)) { // 1. Call collapse() on the context object's selection, with first argument start block and second argument // start block's length. MUST(selection.collapse(start_block, start_block->length())); // 2. Let reference node be start block. auto reference_node = start_block; // 3. While reference node is not a child of end block, set reference node to its parent. while (reference_node->parent() && reference_node->parent() != end_block) reference_node = reference_node->parent(); // 4. If reference node's nextSibling is an inline node and start block's lastChild is a br, remove start // block's lastChild from it. if (reference_node->next_sibling() && is_inline_node(*reference_node->next_sibling()) && is(start_block->last_child())) start_block->last_child()->remove(); // 5. Let nodes to move be a list of nodes, initially empty. Vector> nodes_to_move; // 6. If reference node's nextSibling is neither null nor a block node, append it to nodes to move. if (reference_node->next_sibling() && !is_block_node(*reference_node->next_sibling())) nodes_to_move.append(*reference_node->next_sibling()); // 7. While nodes to move is nonempty and its last member isn't a br and its last member's nextSibling is // neither null nor a block node, append its last member's nextSibling to nodes to move. while (!nodes_to_move.is_empty() && !is(*nodes_to_move.last()) && nodes_to_move.last()->next_sibling() && !is_block_node(*nodes_to_move.last()->next_sibling())) nodes_to_move.append(*nodes_to_move.last()->next_sibling()); // 8. Record the values of nodes to move, and let values be the result. values = record_the_values_of_nodes(document.heap(), nodes_to_move); // 9. For each node in nodes to move, append node as the last child of start block, preserving ranges. auto new_position = start_block->length(); for (auto node : nodes_to_move) move_node_preserving_ranges(node, *start_block, new_position++); } // 34. Otherwise: else { // 1. Call collapse() on the context object's selection, with first argument start block and second argument // start block's length. MUST(selection.collapse(start_block, start_block->length())); // 2. If end block's firstChild is an inline node and start block's lastChild is a br, remove start block's // lastChild from it. if (end_block->first_child() && is_inline_node(*end_block->first_child()) && start_block->last_child() && is(*start_block->last_child())) start_block->last_child()->remove(); // 3. Record the values of end block's children, and let values be the result. Vector> end_block_children; end_block_children.ensure_capacity(end_block->child_count()); end_block->for_each_child([&end_block_children](auto& child) { end_block_children.append(child); return IterationDecision::Continue; }); values = record_the_values_of_nodes(document.heap(), end_block_children); // 4. While end block has children, append the first child of end block to start block, preserving ranges. auto new_position = start_block->length(); while (end_block->has_children()) move_node_preserving_ranges(*end_block->first_child(), *start_block, new_position++); // 5. While end block has no children, let parent be the parent of end block, then remove end block from parent, // then set end block to parent. while (end_block->parent() && !end_block->has_children()) { GC::Ptr parent = end_block->parent(); end_block->remove(); end_block = parent; } } // 36. Let ancestor be start block. auto ancestor = start_block; // 37. While ancestor has an inclusive ancestor ol in the same editing host whose nextSibling is also an ol in the // same editing host, or an inclusive ancestor ul in the same editing host whose nextSibling is also a ul in the // same editing host: while (true) { bool has_valid_ol_or_ul_ancestor = false; ancestor->for_each_inclusive_ancestor([&](GC::Ref inclusive_ancestor) { if (inclusive_ancestor->next_sibling() && is_in_same_editing_host(*ancestor, *inclusive_ancestor) && is_in_same_editing_host(*inclusive_ancestor, *inclusive_ancestor->next_sibling()) && ((is(*inclusive_ancestor) && is(*inclusive_ancestor->next_sibling())) || (is(*inclusive_ancestor) && is(*inclusive_ancestor->next_sibling())))) { has_valid_ol_or_ul_ancestor = true; return IterationDecision::Break; } return IterationDecision::Continue; }); if (!has_valid_ol_or_ul_ancestor) break; // 1. While ancestor and its nextSibling are not both ols in the same editing host, and are also not both uls in // the same editing host, set ancestor to its parent. while (ancestor->parent()) { if (ancestor->next_sibling() && is_in_same_editing_host(*ancestor, *ancestor->next_sibling())) { if (is(*ancestor) && is(*ancestor->next_sibling())) break; if (is(*ancestor) && is(*ancestor->next_sibling())) break; } ancestor = ancestor->parent(); } // 2. While ancestor's nextSibling has children, append ancestor's nextSibling's firstChild as the last child of // ancestor, preserving ranges. auto new_position = ancestor->length(); while (ancestor->next_sibling()->has_children()) move_node_preserving_ranges(*ancestor->next_sibling()->first_child(), *ancestor, new_position++); // 3. Remove ancestor's nextSibling from its parent. ancestor->next_sibling()->remove(); } // 38. Restore the values from values. restore_the_values_of_nodes(values); // 39. If start block has no children, call createElement("br") on the context object and append the result as the // last child of start block. if (!start_block->has_children()) MUST(start_block->append_child(MUST(DOM::create_element(document, HTML::TagNames::br, Namespace::HTML)))); // 40. Remove extraneous line breaks at the end of start block. remove_extraneous_line_breaks_at_the_end_of_node(*start_block); // 41. Restore states and values from overrides. restore_states_and_values(document, overrides); } // https://w3c.github.io/editing/docs/execCommand/#effective-command-value Optional effective_command_value(GC::Ptr node, FlyString const& command) { VERIFY(node); // 1. If neither node nor its parent is an Element, return null. // 2. If node is not an Element, return the effective command value of its parent for command. if (!is(*node)) { if (!node->parent() || !is(*node->parent())) return {}; return effective_command_value(node->parent(), command); } // 3. If command is "createLink" or "unlink": auto node_as_element = [&] -> GC::Ref { return static_cast(*node); }; if (command.is_one_of(CommandNames::createLink, CommandNames::unlink)) { // 1. While node is not null, and is not an a element that has an href attribute, set node to its parent. while (node && !(is(*node) && node_as_element()->has_attribute(HTML::AttributeNames::href))) node = node->parent(); // 2. If node is null, return null. if (!node) return {}; // 3. Return the value of node's href attribute. return Utf16String::from_utf8_without_validation(node_as_element()->get_attribute_value(HTML::AttributeNames::href)); } // 4. If command is "backColor" or "hiliteColor": if (command.is_one_of(CommandNames::backColor, CommandNames::hiliteColor)) { // 1. While the resolved value of "background-color" on node is any fully transparent value, and node's parent // is an Element, set node to its parent. auto resolved_background_color = [&] { return resolved_value(*node, CSS::PropertyID::BackgroundColor); }; auto resolved_background_alpha = [&] { auto background_color = resolved_background_color(); if (!background_color) return NumericLimits::max(); VERIFY(is(node->layout_node())); return background_color->to_color(CSS::ColorResolutionContext::for_layout_node_with_style(*static_cast(node->layout_node()))).value().alpha(); }; while (resolved_background_alpha() == 0 && node->parent() && is(*node->parent())) node = node->parent(); // 2. Return the resolved value of "background-color" for node. auto resolved_value = resolved_background_color(); if (!resolved_value) return {}; return Utf16String::from_utf8_without_validation(resolved_value->to_string(CSS::SerializationMode::ResolvedValue)); } // 5. If command is "subscript" or "superscript": if (command.is_one_of(CommandNames::subscript, CommandNames::superscript)) { // 1. Let affected by subscript and affected by superscript be two boolean variables, both initially false. bool affected_by_subscript = false; bool affected_by_superscript = false; // 2. While node is an inline node: while (node && is_inline_node(*node)) { // 1. If node is a sub, set affected by subscript to true. if (is(*node) && node_as_element()->local_name() == HTML::TagNames::sub) { affected_by_subscript = true; } // 2. Otherwise, if node is a sup, set affected by superscript to true. else if (is(*node) && node_as_element()->local_name() == HTML::TagNames::sup) { affected_by_superscript = true; } // 3. Set node to its parent. node = node->parent(); } // 3. If affected by subscript and affected by superscript are both true, return the string "mixed". if (affected_by_subscript && affected_by_superscript) return "mixed"_utf16; // 4. If affected by subscript is true, return "subscript". if (affected_by_subscript) return "subscript"_utf16; // 5. If affected by superscript is true, return "superscript". if (affected_by_superscript) return "superscript"_utf16; // 6. Return null. return {}; } // 6. If command is "strikethrough", and the "text-decoration" property of node or any of its ancestors has resolved // value containing "line-through", return "line-through". Otherwise, return null. if (command == CommandNames::strikethrough) { auto inclusive_ancestor = node; do { auto text_decoration_line = resolved_value(*node, CSS::PropertyID::TextDecorationLine); if (text_decoration_line && value_contains_keyword(*text_decoration_line, CSS::Keyword::LineThrough)) return "line-through"_utf16; inclusive_ancestor = inclusive_ancestor->parent(); } while (inclusive_ancestor); return {}; } // 7. If command is "underline", and the "text-decoration" property of node or any of its ancestors has resolved // value containing "underline", return "underline". Otherwise, return null. if (command == CommandNames::underline) { auto inclusive_ancestor = node; do { auto text_decoration_line = resolved_value(*node, CSS::PropertyID::TextDecorationLine); if (text_decoration_line && value_contains_keyword(*text_decoration_line, CSS::Keyword::Underline)) return "underline"_utf16; inclusive_ancestor = inclusive_ancestor->parent(); } while (inclusive_ancestor); return {}; } // 8. Return the resolved value for node of the relevant CSS property for command. auto const& command_definition = find_command_definition(command).release_value(); VERIFY(command_definition.relevant_css_property.has_value()); auto optional_value = resolved_value(*node, command_definition.relevant_css_property.value()); if (!optional_value) return {}; return Utf16String::from_utf8_without_validation(optional_value->to_string(CSS::SerializationMode::ResolvedValue)); } // https://w3c.github.io/editing/docs/execCommand/#first-equivalent-point DOM::BoundaryPoint first_equivalent_point(DOM::BoundaryPoint boundary_point) { // 1. While (node, offset)'s previous equivalent point is not null, set (node, offset) to its previous equivalent // point. while (true) { auto previous_point = previous_equivalent_point(boundary_point); if (!previous_point.has_value()) break; boundary_point = previous_point.release_value(); } // 2. Return (node, offset). return boundary_point; } // https://w3c.github.io/editing/docs/execCommand/#fix-disallowed-ancestors void fix_disallowed_ancestors_of_node(GC::Ref node) { // 1. If node is not editable, abort these steps. if (!node->is_editable()) return; // 2. If node is not an allowed child of any of its ancestors in the same editing host: bool allowed_child_of_any_ancestor = false; node->for_each_ancestor([&](GC::Ref ancestor) { if (is_in_same_editing_host(ancestor, node) && is_allowed_child_of_node(node, ancestor)) { allowed_child_of_any_ancestor = true; return IterationDecision::Break; } return IterationDecision::Continue; }); if (!allowed_child_of_any_ancestor) { // 1. If node is a dd or dt, wrap the one-node list consisting of node, with sibling criteria returning true for // any dl with no attributes and false otherwise, and new parent instructions returning the result of calling // createElement("dl") on the context object. Then abort these steps. if (is(*node) && static_cast(*node).local_name().is_one_of(HTML::TagNames::dd, HTML::TagNames::dt)) { wrap( { node }, [](GC::Ref sibling) { if (!is(*sibling)) return false; auto& sibling_element = static_cast(*sibling); return sibling_element.local_name() == HTML::TagNames::dl && !sibling_element.has_attributes(); }, [&node] { return MUST(DOM::create_element(node->document(), HTML::TagNames::dl, Namespace::HTML)); }); return; } // 2. If "p" is not an allowed child of the editing host of node, abort these steps. if (!is_allowed_child_of_node(HTML::TagNames::p, GC::Ref { *node->editing_host() })) return; // 3. If node is not a prohibited paragraph child, abort these steps. if (!is_prohibited_paragraph_child(node)) return; // 4. Set the tag name of node to the default single-line container name, and let node be the result. node = set_the_tag_name(static_cast(*node), node->document().default_single_line_container_name()); // 5. Fix disallowed ancestors of node. fix_disallowed_ancestors_of_node(node); // 6. Let children be node's children. // 7. For each child in children, if child is a prohibited paragraph child: node->for_each_child([](DOM::Node& child) { if (!is_prohibited_paragraph_child(child)) return IterationDecision::Continue; // 1. Record the values of the one-node list consisting of child, and let values be the result. auto values = record_the_values_of_nodes(child.heap(), { child }); // 2. Split the parent of the one-node list consisting of child. split_the_parent_of_nodes({ child }); // 3. Restore the values from values. restore_the_values_of_nodes(values); return IterationDecision::Continue; }); // 8. Abort these steps. return; } // 3. Record the values of the one-node list consisting of node, and let values be the result. auto values = record_the_values_of_nodes(node->heap(), { node }); // 4. While node is not an allowed child of its parent, split the parent of the one-node list consisting of node. while (!is_allowed_child_of_node(node, GC::Ref { *node->parent() })) split_the_parent_of_nodes({ node }); // 5. Restore the values from values. restore_the_values_of_nodes(values); } // https://w3c.github.io/editing/docs/execCommand/#follows-a-line-break bool follows_a_line_break(GC::Ref node) { // 1. Let offset be zero. auto offset = 0u; // 2. While (node, offset) is not a block boundary point: while (!is_block_boundary_point({ node, offset })) { // 1. If node has a visible child with index offset minus one, return false. auto* offset_minus_one_child = node->child_at_index(offset - 1); if (offset_minus_one_child && is_visible_node(*offset_minus_one_child)) return false; // 2. If offset is zero or node has no children, set offset to node's index, then set node // to its parent. if (offset == 0 || node->child_count() == 0) { offset = node->index(); node = *node->parent(); } // 3. Otherwise, set node to its child with index offset minus one, then set offset to // node's length. else { node = *node->child_at_index(offset - 1); offset = node->length(); } } // 3. Return true. return true; } // https://w3c.github.io/editing/docs/execCommand/#force-the-value void force_the_value(GC::Ref node, FlyString const& command, Optional new_value) { // 1. Let command be the current command. // 2. If node's parent is null, abort this algorithm. if (!node->parent()) return; // 3. If new value is null, abort this algorithm. if (!new_value.has_value()) return; // 4. If node is an allowed child of "span": if (is_allowed_child_of_node(node, HTML::TagNames::span)) { // 1. Reorder modifiable descendants of node's previousSibling. if (node->previous_sibling()) reorder_modifiable_descendants(*node->previous_sibling(), command, new_value); // 2. Reorder modifiable descendants of node's nextSibling. if (node->next_sibling()) reorder_modifiable_descendants(*node->next_sibling(), command, new_value); // 3. Wrap the one-node list consisting of node, with sibling criteria returning true for a simple modifiable // element whose specified command value is equivalent to new value and whose effective command value is // loosely equivalent to new value and false otherwise, and with new parent instructions returning null. wrap( { node }, [&](GC::Ref sibling) { return is_simple_modifiable_element(sibling) && specified_command_value(static_cast(*sibling), command) == new_value && values_are_loosely_equivalent(command, effective_command_value(sibling, command), new_value); }, [] -> GC::Ptr { return {}; }); } // 5. If node is invisible, abort this algorithm. if (is_invisible_node(node)) return; // 6. If the effective command value of command is loosely equivalent to new value on node, abort this algorithm. if (values_are_loosely_equivalent(command, effective_command_value(node, command), new_value)) return; // 7. If node is not an allowed child of "span": if (!is_allowed_child_of_node(node, HTML::TagNames::span)) { // 1. Let children be all children of node, omitting any that are Elements whose specified command value for // command is neither null nor equivalent to new value. Vector> children; node->for_each_child([&](GC::Ref child) { if (is(*child)) { auto const child_specified_value = specified_command_value(static_cast(*child), command); if (child_specified_value.has_value() && !values_are_equivalent(command, child_specified_value.value(), new_value)) return IterationDecision::Continue; } children.append(child); return IterationDecision::Continue; }); // 2. Force the value of each node in children, with command and new value as in this invocation of the // algorithm. for (auto child : children) force_the_value(child, command, new_value); // 3. Abort this algorithm. return; } // 8. If the effective command value of command is loosely equivalent to new value on node, abort this algorithm. if (values_are_loosely_equivalent(command, effective_command_value(node, command), new_value)) return; // 9. Let new parent be null. GC::Ptr new_parent; // 10. If the CSS styling flag is false: auto& document = node->document(); if (!document.css_styling_flag()) { // 1. If command is "bold" and new value is "bold", let new parent be the result of calling createElement("b") // on the ownerDocument of node. if (command == CommandNames::bold && new_value == "bold"sv) new_parent = MUST(DOM::create_element(document, HTML::TagNames::b, Namespace::HTML)); // 2. If command is "italic" and new value is "italic", let new parent be the result of calling // createElement("i") on the ownerDocument of node. if (command == CommandNames::italic && new_value == "italic"sv) new_parent = MUST(DOM::create_element(document, HTML::TagNames::i, Namespace::HTML)); // 3. If command is "strikethrough" and new value is "line-through", let new parent be the result of calling // createElement("s") on the ownerDocument of node. if (command == CommandNames::strikethrough && new_value == "line-through"sv) new_parent = MUST(DOM::create_element(document, HTML::TagNames::s, Namespace::HTML)); // 4. If command is "underline" and new value is "underline", let new parent be the result of calling // createElement("u") on the ownerDocument of node. if (command == CommandNames::underline && new_value == "underline"sv) new_parent = MUST(DOM::create_element(document, HTML::TagNames::u, Namespace::HTML)); // 5. If command is "foreColor", and new value is fully opaque with red, green, and blue components in the // range 0 to 255: if (command == CommandNames::foreColor) { auto new_value_color = Color::from_utf16_string(new_value.value()); if (new_value_color->alpha() == NumericLimits::max()) { // 1. Let new parent be the result of calling createElement("font") on the ownerDocument of node. new_parent = MUST(DOM::create_element(document, HTML::TagNames::font, Namespace::HTML)); // 2. Set the color attribute of new parent to the result of applying the rules for serializing simple color // values to new value (interpreted as a simple color). new_parent->set_attribute_value(HTML::AttributeNames::color, new_value_color->to_string_without_alpha()); } } // 6. If command is "fontName", let new parent be the result of calling createElement("font") on the // ownerDocument of node, then set the face attribute of new parent to new value. if (command == CommandNames::fontName) { new_parent = MUST(DOM::create_element(document, HTML::TagNames::font, Namespace::HTML)); new_parent->set_attribute_value(HTML::AttributeNames::face, new_value.value().to_utf8_but_should_be_ported_to_utf16()); } } // 11. If command is "createLink" or "unlink": if (command.is_one_of(CommandNames::createLink, CommandNames::unlink)) { // 1. Let new parent be the result of calling createElement("a") on the ownerDocument of node. new_parent = MUST(DOM::create_element(document, HTML::TagNames::a, Namespace::HTML)); // 2. Set the href attribute of new parent to new value. new_parent->set_attribute_value(HTML::AttributeNames::href, new_value.value().to_utf8_but_should_be_ported_to_utf16()); // 3. Let ancestor be node's parent. GC::Ptr ancestor = node->parent(); // 4. While ancestor is not null: while (ancestor) { // 1. If ancestor is an a, set the tag name of ancestor to "span", and let ancestor be the result. if (is(*ancestor)) ancestor = set_the_tag_name(static_cast(*ancestor), HTML::TagNames::span); // 2. Set ancestor to its parent. ancestor = ancestor->parent(); } } // 12. If command is "fontSize"; and new value is one of "x-small", "small", "medium", "large", "x-large", // "xx-large", or "xxx-large"; and either the CSS styling flag is false, or new value is "xxx-large": auto const& font_sizes = named_font_sizes(); if (command == CommandNames::fontSize && font_sizes.contains_slow(new_value.value()) && (!document.css_styling_flag() || new_value == "xxx-large"sv)) { // let new parent be the result of calling createElement("font") on the ownerDocument of node, new_parent = MUST(DOM::create_element(document, HTML::TagNames::font, Namespace::HTML)); // then set the size attribute of new parent to the number from the following table based on new value: // * x-small: 1 // * small: 2 // * normal: 3 // * large: 4 // * x-large: 5 // * xx-large: 6 // * xxx-large: 7 auto size = font_sizes.first_index_of(new_value.value()).value() + 1; new_parent->set_attribute_value(HTML::AttributeNames::size, String::number(size)); } // 13. If command is "subscript" or "superscript" and new value is "subscript", let new parent be the result of // calling createElement("sub") on the ownerDocument of node. if (command.is_one_of(CommandNames::subscript, CommandNames::superscript) && new_value == "subscript"sv) new_parent = MUST(DOM::create_element(document, HTML::TagNames::sub, Namespace::HTML)); // 14. If command is "subscript" or "superscript" and new value is "superscript", let new parent be the result of // calling createElement("sup") on the ownerDocument of node. if (command.is_one_of(CommandNames::subscript, CommandNames::superscript) && new_value == "superscript"sv) new_parent = MUST(DOM::create_element(document, HTML::TagNames::sup, Namespace::HTML)); // 15. If new parent is null, let new parent be the result of calling createElement("span") on the ownerDocument of // node. if (!new_parent) new_parent = MUST(DOM::create_element(document, HTML::TagNames::span, Namespace::HTML)); // 16. Insert new parent in node's parent before node. node->parent()->insert_before(*new_parent, node); // 17. If the effective command value of command for new parent is not loosely equivalent to new value, and the // relevant CSS property for command is not null, set that CSS property of new parent to new value (if the new // value would be valid). if (!values_are_loosely_equivalent(command, effective_command_value(new_parent, command), new_value)) { auto const& command_definition = find_command_definition(command); if (command_definition->relevant_css_property.has_value()) { auto inline_style = new_parent->style_for_bindings(); MUST(inline_style->set_property(command_definition->relevant_css_property.value(), new_value.value().to_utf8_but_should_be_ported_to_utf16())); } } // 18. If command is "strikethrough", and new value is "line-through", and the effective command value of // "strikethrough" for new parent is not "line-through", set the "text-decoration" property of new parent to // "line-through". if (command == CommandNames::strikethrough && new_value == "line-through"sv && effective_command_value(new_parent, command) != "line-through"sv) { auto inline_style = new_parent->style_for_bindings(); MUST(inline_style->set_property(CSS::PropertyID::TextDecoration, "line-through"sv)); } // 19. If command is "underline", and new value is "underline", and the effective command value of "underline" for // new parent is not "underline", set the "text-decoration" property of new parent to "underline". if (command == CommandNames::underline && new_value == "underline"sv && effective_command_value(new_parent, command) != "underline"sv) { auto inline_style = new_parent->style_for_bindings(); MUST(inline_style->set_property(CSS::PropertyID::TextDecoration, "underline"sv)); } // 20. Append node to new parent as its last child, preserving ranges. move_node_preserving_ranges(node, *new_parent, new_parent->child_count()); // 21. If node is an Element and the effective command value of command for node is not loosely equivalent to new // value: if (is(*node) && !values_are_loosely_equivalent(command, effective_command_value(node, command), new_value)) { // 1. Insert node into the parent of new parent before new parent, preserving ranges. move_node_preserving_ranges(node, *new_parent->parent(), new_parent->index()); // 2. Remove new parent from its parent. new_parent->remove(); // 3. Let children be all children of node, omitting any that are Elements whose specified command value for // command is neither null nor equivalent to new value. Vector> children; node->for_each_child([&](GC::Ref child) { if (is(*child)) { auto child_value = specified_command_value(static_cast(*child), command); if (child_value.has_value() && !values_are_equivalent(command, child_value.value(), new_value)) return IterationDecision::Continue; } children.append(child); return IterationDecision::Continue; }); // 4. Force the value of each node in children, with command and new value as in this invocation of the // algorithm. for (auto child : children) force_the_value(child, command, new_value); } } // https://w3c.github.io/editing/docs/execCommand/#indent void indent(Vector> node_list) { // 1. If node list is empty, do nothing and abort these steps. if (node_list.is_empty()) return; // 2. Let first node be the first member of node list. auto first_node = node_list.first(); // 3. If first node's parent is an ol or ul: if (is(first_node->parent()) || is(first_node->parent())) { // 1. Let tag be the local name of the parent of first node. auto tag = static_cast(first_node->parent())->local_name(); // 2. Wrap node list, with sibling criteria returning true for an HTML element with local name tag and false // otherwise, and new parent instructions returning the result of calling createElement(tag) on the // ownerDocument of first node. wrap( node_list, [&](GC::Ref sibling) { return is(*sibling) && static_cast(*sibling).local_name() == tag; }, [&] { return MUST(DOM::create_element(*first_node->owner_document(), tag, Namespace::HTML)); }); // 3. Abort these steps. return; } // 4. Wrap node list, with sibling criteria returning true for a simple indentation element and false otherwise, and // new parent instructions returning the result of calling createElement("blockquote") on the ownerDocument of // first node. Let new parent be the result. auto new_parent = wrap( node_list, [&](GC::Ref sibling) { return is_simple_indentation_element(sibling); }, [&] { return MUST(DOM::create_element(*first_node->owner_document(), HTML::TagNames::blockquote, Namespace::HTML)); }); // 5. Fix disallowed ancestors of new parent. if (new_parent) fix_disallowed_ancestors_of_node(*new_parent); } // https://w3c.github.io/editing/docs/execCommand/#allowed-child bool is_allowed_child_of_node(Variant, FlyString> child, Variant, FlyString> parent) { GC::Ptr child_node; if (child.has>()) child_node = child.get>(); GC::Ptr parent_node; if (parent.has>()) parent_node = parent.get>(); if (parent.has() || is(parent_node.ptr())) { auto parent_local_name = parent.visit( [](FlyString local_name) { return local_name; }, [](GC::Ref node) { return static_cast(*node).local_name(); }); // 1. If parent is "colgroup", "table", "tbody", "tfoot", "thead", "tr", or an HTML element with local name equal to // one of those, and child is a Text node whose data does not consist solely of space characters, return false. auto parent_is_table_like = parent_local_name.is_one_of(HTML::TagNames::colgroup, HTML::TagNames::table, HTML::TagNames::tbody, HTML::TagNames::tfoot, HTML::TagNames::thead, HTML::TagNames::tr); if (parent_is_table_like && is(child_node.ptr())) { auto child_text_content = child_node->text_content().release_value(); if (!all_of(child_text_content, Infra::is_ascii_whitespace)) return false; } // 2. If parent is "script", "style", "plaintext", or "xmp", or an HTML element with local name equal to one of // those, and child is not a Text node, return false. if ((child.has() || !is(child_node.ptr())) && parent_local_name.is_one_of(HTML::TagNames::script, HTML::TagNames::style, HTML::TagNames::plaintext, HTML::TagNames::xmp)) return false; } // 3. If child is a document, DocumentFragment, or DocumentType, return false. if (is(child_node.ptr()) || is(child_node.ptr()) || is(child_node.ptr())) return false; // 4. If child is an HTML element, set child to the local name of child. if (is(child_node.ptr())) child = static_cast(*child_node).local_name(); // 5. If child is not a string, return true. if (!child.has()) return true; auto child_local_name = child.get(); // 6. If parent is an HTML element: if (is(parent_node.ptr())) { auto& parent_html_element = static_cast(*parent.get>()); // 1. If child is "a", and parent or some ancestor of parent is an a, return false. if (child_local_name == HTML::TagNames::a) { DOM::Node* ancestor = &parent_html_element; while (ancestor) { if (is(*ancestor)) return false; ancestor = ancestor->parent(); } } // 2. If child is a prohibited paragraph child name and parent or some ancestor of parent is an element with // inline contents, return false. if (is_prohibited_paragraph_child_name(child_local_name)) { DOM::Node* ancestor = &parent_html_element; while (ancestor) { if (is_element_with_inline_contents(*ancestor)) return false; ancestor = ancestor->parent(); } } // 3. If child is "h1", "h2", "h3", "h4", "h5", or "h6", and parent or some ancestor of parent is an HTML // element with local name "h1", "h2", "h3", "h4", "h5", or "h6", return false. if (is_heading(child_local_name)) { DOM::Node* ancestor = &parent_html_element; while (ancestor) { if (is(*ancestor) && is_heading(static_cast(*ancestor).local_name())) return false; ancestor = ancestor->parent(); } } // 4. Let parent be the local name of parent. parent = parent_html_element.local_name(); parent_node = {}; } // 7. If parent is an Element or DocumentFragment, return true. if (is(parent_node.ptr()) || is(parent_node.ptr())) return true; // 8. If parent is not a string, return false. if (!parent.has()) return false; auto parent_local_name = parent.get(); // 9. If parent is on the left-hand side of an entry on the following list, then return true if child is listed on // the right-hand side of that entry, and false otherwise. // * colgroup: col if (parent_local_name == HTML::TagNames::colgroup) return child_local_name == HTML::TagNames::col; // * table: caption, col, colgroup, tbody, td, tfoot, th, thead, tr if (parent_local_name == HTML::TagNames::table) { return child_local_name.is_one_of( HTML::TagNames::caption, HTML::TagNames::col, HTML::TagNames::colgroup, HTML::TagNames::tbody, HTML::TagNames::td, HTML::TagNames::tfoot, HTML::TagNames::th, HTML::TagNames::thead, HTML::TagNames::tr); } // * tbody, tfoot, thead: td, th, tr if (parent_local_name.is_one_of(HTML::TagNames::tbody, HTML::TagNames::tfoot, HTML::TagNames::thead)) return child_local_name.is_one_of(HTML::TagNames::td, HTML::TagNames::th, HTML::TagNames::tr); // * tr: td, th if (parent_local_name == HTML::TagNames::tr) return child_local_name.is_one_of(HTML::TagNames::td, HTML::TagNames::th); // * dl: dt, dd if (parent_local_name == HTML::TagNames::dl) return child_local_name.is_one_of(HTML::TagNames::dt, HTML::TagNames::dd); // * dir, ol, ul: dir, li, ol, ul if (parent_local_name.is_one_of(HTML::TagNames::dir, HTML::TagNames::ol, HTML::TagNames::ul)) return child_local_name.is_one_of(HTML::TagNames::dir, HTML::TagNames::li, HTML::TagNames::ol, HTML::TagNames::ul); // * hgroup: h1, h2, h3, h4, h5, h6 if (parent_local_name == HTML::TagNames::hgroup) return is_heading(child_local_name); // 10. If child is "body", "caption", "col", "colgroup", "frame", "frameset", "head", "html", "tbody", "td", // "tfoot", "th", "thead", or "tr", return false. if (child_local_name.is_one_of( HTML::TagNames::body, HTML::TagNames::caption, HTML::TagNames::col, HTML::TagNames::colgroup, HTML::TagNames::frame, HTML::TagNames::frameset, HTML::TagNames::head, HTML::TagNames::html, HTML::TagNames::tbody, HTML::TagNames::td, HTML::TagNames::tfoot, HTML::TagNames::th, HTML::TagNames::thead, HTML::TagNames::tr)) return false; // 11. If child is "dd" or "dt" and parent is not "dl", return false. if (child_local_name.is_one_of(HTML::TagNames::dd, HTML::TagNames::dt) && parent_local_name != HTML::TagNames::dl) return false; // 12. If child is "li" and parent is not "ol" or "ul", return false. if (child_local_name == HTML::TagNames::li && parent_local_name != HTML::TagNames::ol && parent_local_name != HTML::TagNames::ul) return false; // 13. If parent is on the left-hand side of an entry on the following list and child is listed on the right-hand // side of that entry, return false. // * a: a if (parent_local_name == HTML::TagNames::a && child_local_name == HTML::TagNames::a) return false; // * dd, dt: dd, dt if (parent_local_name.is_one_of(HTML::TagNames::dd, HTML::TagNames::dt) && child_local_name.is_one_of(HTML::TagNames::dd, HTML::TagNames::dt)) return false; // * h1, h2, h3, h4, h5, h6: h1, h2, h3, h4, h5, h6 if (is_heading(parent_local_name) && is_heading(child_local_name)) return false; // * li: li if (parent_local_name == HTML::TagNames::li && child_local_name == HTML::TagNames::li) return false; // * nobr: nobr if (parent_local_name == HTML::TagNames::nobr && child_local_name == HTML::TagNames::nobr) return false; // * All names of an element with inline contents: all prohibited paragraph child names if (is_name_of_an_element_with_inline_contents(parent_local_name) && is_prohibited_paragraph_child_name(child_local_name)) return false; // * td, th: caption, col, colgroup, tbody, td, tfoot, th, thead, tr if (parent_local_name.is_one_of(HTML::TagNames::td, HTML::TagNames::th) && child_local_name.is_one_of( HTML::TagNames::caption, HTML::TagNames::col, HTML::TagNames::colgroup, HTML::TagNames::tbody, HTML::TagNames::td, HTML::TagNames::tfoot, HTML::TagNames::th, HTML::TagNames::thead, HTML::TagNames::tr)) return false; // 14. Return true. return true; } // https://w3c.github.io/editing/docs/execCommand/#block-boundary-point bool is_block_boundary_point(DOM::BoundaryPoint boundary_point) { // A boundary point is a block boundary point if it is either a block start point or a block end point. return is_block_start_point(boundary_point) || is_block_end_point(boundary_point); } // https://w3c.github.io/editing/docs/execCommand/#block-end-point bool is_block_end_point(DOM::BoundaryPoint boundary_point) { // A boundary point (node, offset) is a block end point if either node's parent is null and offset is node's length; if (!boundary_point.node->parent() && boundary_point.offset == boundary_point.node->length()) return true; // or node has a child with index offset, and that child is a visible block node. auto offset_child = boundary_point.node->child_at_index(boundary_point.offset); return offset_child && is_visible_node(*offset_child) && is_block_node(*offset_child); } // https://w3c.github.io/editing/docs/execCommand/#block-node bool is_block_node(GC::Ref node) { // A block node is either an Element whose "display" property does not have resolved value // "inline" or "inline-block" or "inline-table" or "none", or a document, or a DocumentFragment. if (is(*node) || is(*node)) return true; if (!is(*node)) return false; auto display = resolved_display(node); if (!display.has_value()) return true; return !(display->is_inline_outside() && (display->is_flow_inside() || display->is_flow_root_inside() || display->is_table_inside())) && !display->is_none(); } // https://w3c.github.io/editing/docs/execCommand/#block-start-point bool is_block_start_point(DOM::BoundaryPoint boundary_point) { // A boundary point (node, offset) is a block start point if either node's parent is null and offset is zero; if (!boundary_point.node->parent() && boundary_point.offset == 0) return true; // or node has a child with index offset − 1, and that child is either a visible block node or a visible br. auto offset_minus_one_child = boundary_point.node->child_at_index(boundary_point.offset - 1); return offset_minus_one_child && is_visible_node(*offset_minus_one_child) && (is_block_node(*offset_minus_one_child) || is(*offset_minus_one_child)); } // https://w3c.github.io/editing/docs/execCommand/#collapsed-block-prop bool is_collapsed_block_prop(GC::Ref node) { // A collapsed block prop is either a collapsed line break that is not an extraneous line break, if (is_collapsed_line_break(node) && !is_extraneous_line_break(node)) return true; // or an Element that is an inline node if (!is(*node) || !is_inline_node(node)) return false; // and whose children are all either invisible or collapsed block props bool children_all_invisible_or_collapsed = true; bool has_collapsed_block_prop = false; node->for_each_child([&](GC::Ref child) { auto child_is_collapsed_block_prop = is_collapsed_block_prop(child); if (!is_invisible_node(child) && !child_is_collapsed_block_prop) { children_all_invisible_or_collapsed = false; return IterationDecision::Break; } if (child_is_collapsed_block_prop) has_collapsed_block_prop = true; return IterationDecision::Continue; }); if (!children_all_invisible_or_collapsed) return false; // and that has at least one child that is a collapsed block prop. return has_collapsed_block_prop; } // https://w3c.github.io/editing/docs/execCommand/#collapsed-line-break bool is_collapsed_line_break(GC::Ref node) { // A collapsed line break is a br if (!is(*node)) return false; // that begins a line box which has nothing else in it, and therefore has zero height. // AD-HOC: We check this on the DOM level by seeing if the next node is neither a non-empty text node nor a
. if (auto text_node = as_if(node->next_sibling())) return text_node->text_content().value_or({}).is_empty(); return !is(node->next_sibling()); } // https://w3c.github.io/editing/docs/execCommand/#collapsed-whitespace-node bool is_collapsed_whitespace_node(GC::Ref node) { // 1. If node is not a whitespace node, return false. if (!is_whitespace_node(node)) return false; // 2. If node's data is the empty string, return true. auto node_data = node->text_content(); if (!node_data.has_value() || node_data->is_empty()) return true; // 3. Let ancestor be node's parent. GC::Ptr ancestor = node->parent(); // 4. If ancestor is null, return true. if (!ancestor) return true; // 5. If the "display" property of some ancestor of node has resolved value "none", return true. GC::Ptr some_ancestor = node->parent(); while (some_ancestor) { auto display = resolved_display(*some_ancestor); if (display.has_value() && display->is_none()) return true; some_ancestor = some_ancestor->parent(); } // 6. While ancestor is not a block node and its parent is not null, set ancestor to its parent. while (!is_block_node(*ancestor) && ancestor->parent()) ancestor = ancestor->parent(); // 7. Let reference be node. GC::Ptr reference = node; // 8. While reference is a descendant of ancestor: while (reference->is_descendant_of(*ancestor)) { // 1. Let reference be the node before it in tree order. reference = reference->previous_in_pre_order(); // 2. If reference is a block node or a br, return true. if (is_block_node(*reference) || is(*reference)) return true; // 3. If reference is a Text node that is not a whitespace node, or is an img, break from // this loop. if ((is(*reference) && !is_whitespace_node(*reference)) || is(*reference)) break; } // 9. Let reference be node. reference = node; // 10. While reference is a descendant of ancestor: while (reference->is_descendant_of(*ancestor)) { // 1. Let reference be the node after it in tree order, or null if there is no such node. reference = reference->next_in_pre_order(); // NOTE: Both steps below and the loop condition require a reference, so break if it's null. if (!reference) break; // 2. If reference is a block node or a br, return true. if (is_block_node(*reference) || is(*reference)) return true; // 3. If reference is a Text node that is not a whitespace node, or is an img, break from // this loop. if ((is(*reference) && !is_whitespace_node(*reference)) || is(*reference)) break; } // 11. Return false. return false; } // https://w3c.github.io/editing/docs/execCommand/#effectively-contained bool is_effectively_contained_in_range(GC::Ref node, GC::Ref range) { // A node node is effectively contained in a range range if range is not collapsed, and at least one of the // following holds: if (range->collapsed()) return false; // * node is contained in range. if (range->contains_node(node)) return true; // * node is range's start node, it is a Text node, and its length is different from range's start offset. if (node == range->start_container() && is(*node) && node->length() != range->start_offset()) return true; // * node is range's end node, it is a Text node, and range's end offset is not 0. if (node == range->end_container() && is(*node) && range->end_offset() != 0) return true; // * node has at least one child; and all its children are effectively contained in range; if (!node->has_children()) return false; for (auto* child = node->first_child(); child; child = child->next_sibling()) { if (!is_effectively_contained_in_range(*child, range)) return false; } // and either range's start node is not a descendant of node or is not a Text node or range's start offset is zero; auto start_node = range->start_container(); if (start_node->is_descendant_of(node) && is(*start_node) && range->start_offset() != 0) return false; // and either range's end node is not a descendant of node or is not a Text node or range's end offset is its end // node's length. auto end_node = range->end_container(); if (end_node->is_descendant_of(node) && is(*end_node) && range->end_offset() != end_node->length()) return false; return true; } // https://w3c.github.io/editing/docs/execCommand/#element-with-inline-contents bool is_element_with_inline_contents(GC::Ref node) { // An element with inline contents is an HTML element whose local name is a name of an element with inline contents. return is(*node) && is_name_of_an_element_with_inline_contents(static_cast(*node).local_name()); } // https://w3c.github.io/editing/docs/execCommand/#extraneous-line-break bool is_extraneous_line_break(GC::Ref node) { // An extraneous line break is a br if (!is(*node)) return false; // ...except that a br that is the sole child of an li is not extraneous. GC::Ptr parent = node->parent(); if (is(parent.ptr()) && parent->child_count() == 1) return false; // ...that has no visual effect, in that removing it from the DOM would not change layout, // AD-HOC: If node's parent is a block node, and node either has no next sibling or its next sibling is a block // node, and its previous sibling is a visible inline node but not a
, node is extraneous. if (parent && is_block_node(*parent) && node->previous_sibling() && (!node->next_sibling() || is_block_node(*node->next_sibling())) && is_visible_node(*node->previous_sibling()) && is_inline_node(*node->previous_sibling()) && !is(*node->previous_sibling())) { return true; } // FIXME: implement more cases that would cause removing a
not to have any effect on the layout. return false; } // https://w3c.github.io/editing/docs/execCommand/#formattable-block-name bool is_formattable_block_name(FlyString const& local_name) { // A formattable block name is "address", "dd", "div", "dt", "h1", "h2", "h3", "h4", "h5", "h6", "p", or "pre". return local_name.is_one_of(HTML::TagNames::address, HTML::TagNames::dd, HTML::TagNames::div, HTML::TagNames::dt, HTML::TagNames::h1, HTML::TagNames::h2, HTML::TagNames::h3, HTML::TagNames::h4, HTML::TagNames::h5, HTML::TagNames::h6, HTML::TagNames::p, HTML::TagNames::pre); } // https://w3c.github.io/editing/docs/execCommand/#formattable-node bool is_formattable_node(GC::Ref node) { // A formattable node is an editable visible node that is either a Text node, an img, or a br. return node->is_editable() && is_visible_node(node) && (is(*node) || is(*node) || is(*node)); } // https://w3c.github.io/editing/docs/execCommand/#in-the-same-editing-host bool is_in_same_editing_host(GC::Ref node_a, GC::Ref node_b) { // Two nodes are in the same editing host if the editing host of the first is non-null and the // same as the editing host of the second. auto editing_host_a = node_a->editing_host(); auto editing_host_b = node_b->editing_host(); return editing_host_a && editing_host_a == editing_host_b; } // https://w3c.github.io/editing/docs/execCommand/#indentation-element bool is_indentation_element(GC::Ref node) { // An indentation element is either a blockquote, if (!is(*node)) return false; auto& element = static_cast(*node); if (element.local_name() == HTML::TagNames::blockquote) return true; // or a div that has a style attribute that sets "margin" or some subproperty of it. auto inline_style = element.inline_style(); return is(element) && element.has_attribute(HTML::AttributeNames::style) && inline_style && (!inline_style->margin().is_empty() || !inline_style->margin_top().is_empty() || !inline_style->margin_right().is_empty() || !inline_style->margin_bottom().is_empty() || !inline_style->margin_left().is_empty()); } // https://w3c.github.io/editing/docs/execCommand/#inline-node bool is_inline_node(GC::Ref node) { // An inline node is a node that is not a block node. return !is_block_node(node); } // https://w3c.github.io/editing/docs/execCommand/#invisible bool is_invisible_node(GC::Ref node) { // Something is invisible if it is a node that is not visible. return !is_visible_node(node); } // https://w3c.github.io/editing/docs/execCommand/#modifiable-element bool is_modifiable_element(GC::Ref node) { // NOTE: All conditions below expect an HTML element. if (!is(*node)) return false; auto const& html_element = static_cast(*node); // A modifiable element is a b, em, i, s, span, strike, strong, sub, sup, or u element with no attributes except // possibly style; auto has_no_attributes_except = [&](auto exclusions) { auto attribute_count = 0; html_element.for_each_attribute([&](DOM::Attr const& attribute) { if (!exclusions.contains_slow(attribute.local_name())) ++attribute_count; }); return attribute_count == 0; }; if (html_element.local_name().is_one_of(HTML::TagNames::b, HTML::TagNames::em, HTML::TagNames::i, HTML::TagNames::s, HTML::TagNames::span, HTML::TagNames::strike, HTML::TagNames::strong, HTML::TagNames::sub, HTML::TagNames::sup, HTML::TagNames::u)) return has_no_attributes_except(Array { HTML::AttributeNames::style }); // or a font element with no attributes except possibly style, color, face, and/or size; if (is(html_element)) { return has_no_attributes_except(Array { HTML::AttributeNames::style, HTML::AttributeNames::color, HTML::AttributeNames::face, HTML::AttributeNames::size }); } // or an a element with no attributes except possibly style and/or href. return is(html_element) && has_no_attributes_except(Array { HTML::AttributeNames::style, HTML::AttributeNames::href }); } // https://w3c.github.io/editing/docs/execCommand/#name-of-an-element-with-inline-contents bool is_name_of_an_element_with_inline_contents(FlyString const& local_name) { // A name of an element with inline contents is "a", "abbr", "b", "bdi", "bdo", "cite", "code", "dfn", "em", "h1", // "h2", "h3", "h4", "h5", "h6", "i", "kbd", "mark", "p", "pre", "q", "rp", "rt", "ruby", "s", "samp", "small", // "span", "strong", "sub", "sup", "u", "var", "acronym", "listing", "strike", "xmp", "big", "blink", "font", // "marquee", "nobr", or "tt". return local_name.is_one_of( HTML::TagNames::a, HTML::TagNames::abbr, HTML::TagNames::b, HTML::TagNames::bdi, HTML::TagNames::bdo, HTML::TagNames::cite, HTML::TagNames::code, HTML::TagNames::dfn, HTML::TagNames::em, HTML::TagNames::h1, HTML::TagNames::h2, HTML::TagNames::h3, HTML::TagNames::h4, HTML::TagNames::h5, HTML::TagNames::h6, HTML::TagNames::i, HTML::TagNames::kbd, HTML::TagNames::mark, HTML::TagNames::p, HTML::TagNames::pre, HTML::TagNames::q, HTML::TagNames::rp, HTML::TagNames::rt, HTML::TagNames::ruby, HTML::TagNames::s, HTML::TagNames::samp, HTML::TagNames::small, HTML::TagNames::span, HTML::TagNames::strong, HTML::TagNames::sub, HTML::TagNames::sup, HTML::TagNames::u, HTML::TagNames::var, HTML::TagNames::acronym, HTML::TagNames::listing, HTML::TagNames::strike, HTML::TagNames::xmp, HTML::TagNames::big, HTML::TagNames::blink, HTML::TagNames::font, HTML::TagNames::marquee, HTML::TagNames::nobr, HTML::TagNames::tt); } // https://w3c.github.io/editing/docs/execCommand/#non-list-single-line-container bool is_non_list_single_line_container(GC::Ref node) { // A non-list single-line container is an HTML element with local name "address", "div", "h1", "h2", "h3", "h4", // "h5", "h6", "listing", "p", "pre", or "xmp". if (!is(*node)) return false; auto& local_name = static_cast(*node).local_name(); return is_heading(local_name) || local_name.is_one_of(HTML::TagNames::address, HTML::TagNames::div, HTML::TagNames::listing, HTML::TagNames::p, HTML::TagNames::pre, HTML::TagNames::xmp); } // https://w3c.github.io/editing/docs/execCommand/#prohibited-paragraph-child bool is_prohibited_paragraph_child(GC::Ref node) { // A prohibited paragraph child is an HTML element whose local name is a prohibited paragraph child name. return is(*node) && is_prohibited_paragraph_child_name(static_cast(*node).local_name()); } // https://w3c.github.io/editing/docs/execCommand/#prohibited-paragraph-child-name bool is_prohibited_paragraph_child_name(FlyString const& local_name) { // A prohibited paragraph child name is "address", "article", "aside", "blockquote", "caption", "center", "col", // "colgroup", "dd", "details", "dir", "div", "dl", "dt", "fieldset", "figcaption", "figure", "footer", "form", // "h1", "h2", "h3", "h4", "h5", "h6", "header", "hgroup", "hr", "li", "listing", "menu", "nav", "ol", "p", // "plaintext", "pre", "section", "summary", "table", "tbody", "td", "tfoot", "th", "thead", "tr", "ul", or "xmp". return local_name.is_one_of( HTML::TagNames::address, HTML::TagNames::article, HTML::TagNames::aside, HTML::TagNames::blockquote, HTML::TagNames::caption, HTML::TagNames::center, HTML::TagNames::col, HTML::TagNames::colgroup, HTML::TagNames::dd, HTML::TagNames::details, HTML::TagNames::dir, HTML::TagNames::div, HTML::TagNames::dl, HTML::TagNames::dt, HTML::TagNames::fieldset, HTML::TagNames::figcaption, HTML::TagNames::figure, HTML::TagNames::footer, HTML::TagNames::form, HTML::TagNames::h1, HTML::TagNames::h2, HTML::TagNames::h3, HTML::TagNames::h4, HTML::TagNames::h5, HTML::TagNames::h6, HTML::TagNames::header, HTML::TagNames::hgroup, HTML::TagNames::hr, HTML::TagNames::li, HTML::TagNames::listing, HTML::TagNames::menu, HTML::TagNames::nav, HTML::TagNames::ol, HTML::TagNames::p, HTML::TagNames::plaintext, HTML::TagNames::pre, HTML::TagNames::section, HTML::TagNames::summary, HTML::TagNames::table, HTML::TagNames::tbody, HTML::TagNames::td, HTML::TagNames::tfoot, HTML::TagNames::th, HTML::TagNames::thead, HTML::TagNames::tr, HTML::TagNames::ul, HTML::TagNames::xmp); } // https://w3c.github.io/editing/docs/execCommand/#removeformat-candidate bool is_remove_format_candidate(GC::Ref node) { // A removeFormat candidate is an editable HTML element with local name "abbr", "acronym", "b", "bdi", "bdo", "big", // "blink", "cite", "code", "dfn", "em", "font", "i", "ins", "kbd", "mark", "nobr", "q", "s", "samp", "small", // "span", "strike", "strong", "sub", "sup", "tt", "u", or "var". if (!node->is_editable()) return false; if (!is(*node)) return false; return static_cast(*node).local_name().is_one_of( HTML::TagNames::abbr, HTML::TagNames::acronym, HTML::TagNames::b, HTML::TagNames::bdi, HTML::TagNames::bdo, HTML::TagNames::big, HTML::TagNames::blink, HTML::TagNames::cite, HTML::TagNames::code, HTML::TagNames::dfn, HTML::TagNames::em, HTML::TagNames::font, HTML::TagNames::i, HTML::TagNames::ins, HTML::TagNames::kbd, HTML::TagNames::mark, HTML::TagNames::nobr, HTML::TagNames::q, HTML::TagNames::s, HTML::TagNames::samp, HTML::TagNames::small, HTML::TagNames::span, HTML::TagNames::strike, HTML::TagNames::strong, HTML::TagNames::sub, HTML::TagNames::sup, HTML::TagNames::tt, HTML::TagNames::u, HTML::TagNames::var); } // https://w3c.github.io/editing/docs/execCommand/#simple-indentation-element bool is_simple_indentation_element(GC::Ref node) { // A simple indentation element is an indentation element if (!is_indentation_element(node)) return false; auto const& element = static_cast(*node); auto inline_style = element.inline_style(); // that has no attributes except possibly bool has_only_valid_attributes = true; element.for_each_attribute([&](DOM::Attr const& attribute) { // * a style attribute that sets no properties other than "margin", "border", "padding", or subproperties of // those; if (attribute.local_name() == HTML::AttributeNames::style) { if (!inline_style) return; for (auto& style_property : inline_style->properties()) { switch (style_property.property_id) { case CSS::PropertyID::Border: case CSS::PropertyID::BorderBottom: case CSS::PropertyID::BorderLeft: case CSS::PropertyID::BorderRight: case CSS::PropertyID::BorderTop: case CSS::PropertyID::Margin: case CSS::PropertyID::MarginBottom: case CSS::PropertyID::MarginLeft: case CSS::PropertyID::MarginRight: case CSS::PropertyID::MarginTop: case CSS::PropertyID::Padding: case CSS::PropertyID::PaddingBottom: case CSS::PropertyID::PaddingLeft: case CSS::PropertyID::PaddingRight: case CSS::PropertyID::PaddingTop: // Allowed break; default: has_only_valid_attributes = false; return; } } } // * and/or a dir attribute. else if (attribute.local_name() != HTML::AttributeNames::dir) { has_only_valid_attributes = false; } }); return has_only_valid_attributes; } // https://w3c.github.io/editing/docs/execCommand/#simple-modifiable-element bool is_simple_modifiable_element(GC::Ref node) { // A simple modifiable element is an HTML element for which at least one of the following holds: if (!is(*node)) return false; auto const& html_element = static_cast(*node); auto const inline_style = html_element.inline_style(); // * It is an a, b, em, font, i, s, span, strike, strong, sub, sup, or u element with no attributes. // * It is an a, b, em, font, i, s, span, strike, strong, sub, sup, or u element with exactly one attribute, which // is style, which sets no CSS properties (including invalid or unrecognized properties). auto attribute_count = html_element.attribute_list_size(); if (html_element.local_name().is_one_of(HTML::TagNames::a, HTML::TagNames::b, HTML::TagNames::em, HTML::TagNames::font, HTML::TagNames::i, HTML::TagNames::s, HTML::TagNames::span, HTML::TagNames::strike, HTML::TagNames::strong, HTML::TagNames::sub, HTML::TagNames::sup, HTML::TagNames::u)) { if (attribute_count == 0) return true; if (attribute_count == 1 && html_element.has_attribute(HTML::AttributeNames::style) && (!inline_style || inline_style->length() == 0)) return true; } // NOTE: All conditions below require exactly one attribute on the element if (attribute_count != 1) return false; // * It is an a element with exactly one attribute, which is href. if (is(html_element) && html_element.get_attribute(HTML::AttributeNames::href).has_value()) return true; // * It is a font element with exactly one attribute, which is either color, face, or size. if (is(html_element)) { if (html_element.has_attribute(HTML::AttributeNames::color) || html_element.has_attribute(HTML::AttributeNames::face) || html_element.has_attribute(HTML::AttributeNames::size)) return true; } // NOTE: All conditions below require exactly one attribute which is style, that sets one CSS property. if (!html_element.has_attribute(HTML::AttributeNames::style) || !inline_style || (inline_style->length() != 1)) return false; // * It is a b or strong element with exactly one attribute, which is style, and the style attribute sets exactly // one CSS property (including invalid or unrecognized properties), which is "font-weight". if (html_element.local_name().is_one_of(HTML::TagNames::b, HTML::TagNames::strong) && inline_style->has_property(CSS::PropertyID::FontWeight)) return true; // * It is an i or em element with exactly one attribute, which is style, and the style attribute sets exactly one // CSS property (including invalid or unrecognized properties), which is "font-style". if (html_element.local_name().is_one_of(HTML::TagNames::i, HTML::TagNames::em) && inline_style->has_property(CSS::PropertyID::FontStyle)) return true; // * It is an a, font, or span element with exactly one attribute, which is style, and the style attribute sets // exactly one CSS property (including invalid or unrecognized properties), and that property is not // "text-decoration". if (html_element.local_name().is_one_of(HTML::TagNames::a, HTML::TagNames::font, HTML::TagNames::span) && !inline_style->has_property(CSS::PropertyID::TextDecoration)) return true; // * It is an a, font, s, span, strike, or u element with exactly one attribute, which is style, and the style // attribute sets exactly one CSS property (including invalid or unrecognized properties), which is // "text-decoration", which is set to "line-through" or "underline" or "overline" or "none". if (html_element.local_name().is_one_of(HTML::TagNames::a, HTML::TagNames::font, HTML::TagNames::s, HTML::TagNames::span, HTML::TagNames::strike, HTML::TagNames::u) && inline_style->has_property(CSS::PropertyID::TextDecoration)) { auto text_decoration = inline_style->text_decoration(); if (first_is_one_of(text_decoration, string_from_keyword(CSS::Keyword::LineThrough), string_from_keyword(CSS::Keyword::Underline), string_from_keyword(CSS::Keyword::Overline), string_from_keyword(CSS::Keyword::None))) return true; } return false; } // https://w3c.github.io/editing/docs/execCommand/#single-line-container bool is_single_line_container(GC::Ref node) { // A single-line container is either a non-list single-line container, or an HTML element with local name "li", // "dt", or "dd". if (is_non_list_single_line_container(node)) return true; if (!is(*node)) return false; auto& html_element = static_cast(*node); return html_element.local_name().is_one_of(HTML::TagNames::li, HTML::TagNames::dt, HTML::TagNames::dd); } // https://w3c.github.io/editing/docs/execCommand/#visible bool is_visible_node(GC::Ref node) { // excluding any node with an inclusive ancestor Element whose "display" property has resolved // value "none". bool has_display_none = false; node->for_each_inclusive_ancestor([&has_display_none](GC::Ref ancestor) { auto display = resolved_display(ancestor); if (display.has_value() && display->is_none()) { has_display_none = true; return IterationDecision::Break; } return IterationDecision::Continue; }); if (has_display_none) return false; // Something is visible if it is a node that either is a block node, if (is_block_node(node)) return true; // or a Text node that is not a collapsed whitespace node, if (is(*node) && !is_collapsed_whitespace_node(node)) return true; // or an img, if (is(*node)) return true; // or a br that is not an extraneous line break, if (is(*node) && !is_extraneous_line_break(node)) return true; // or any node with a visible descendant; // NOTE: We call into is_visible_node() recursively, so check children instead of descendants. bool has_visible_child_node = false; node->for_each_child([&](DOM::Node& child_node) { if (is_visible_node(child_node)) { has_visible_child_node = true; return IterationDecision::Break; } return IterationDecision::Continue; }); return has_visible_child_node; } // https://w3c.github.io/editing/docs/execCommand/#whitespace-node bool is_whitespace_node(GC::Ref node) { // NOTE: All constraints below check that node is a Text node if (!is(*node)) return false; // A whitespace node is either a Text node whose data is the empty string; auto& character_data = static_cast(*node); if (character_data.data().is_empty()) return true; // NOTE: All constraints below require a parent Element with a resolved value for "white-space-collapse" GC::Ptr parent = node->parent(); if (!is(parent.ptr())) return false; auto resolved_white_space_collapse = resolved_keyword(*parent, CSS::PropertyID::WhiteSpaceCollapse); if (!resolved_white_space_collapse.has_value()) return false; auto white_space_collapse = resolved_white_space_collapse.value(); // or a Text node whose data consists only of one or more tabs (0x0009), line feeds (0x000A), // carriage returns (0x000D), and/or spaces (0x0020), and whose parent is an Element whose // resolved value for "white-space" is "normal" or "nowrap"; // AD-HOC: We use the equivalent "white-space-collapse" longhand property instead of "white-space" shorthand auto is_tab_lf_cr_or_space = [](u32 codepoint) { return codepoint == '\t' || codepoint == '\n' || codepoint == '\r' || codepoint == ' '; }; if (all_of(character_data.data(), is_tab_lf_cr_or_space) && (white_space_collapse == CSS::Keyword::Collapse)) return true; // or a Text node whose data consists only of one or more tabs (0x0009), carriage returns // (0x000D), and/or spaces (0x0020), and whose parent is an Element whose resolved value for // "white-space" is "pre-line". // AD-HOC: We use the equivalent "white-space-collapse" longhand property instead of "white-space" shorthand auto is_tab_cr_or_space = [](u32 codepoint) { return codepoint == '\t' || codepoint == '\r' || codepoint == ' '; }; if (all_of(character_data.data(), is_tab_cr_or_space) && white_space_collapse == CSS::Keyword::PreserveBreaks) return true; return false; } // https://w3c.github.io/editing/docs/execCommand/#justify-the-selection void justify_the_selection(DOM::Document& document, JustifyAlignment alignment) { // 1. Block-extend the active range, and let new range be the result. auto new_range = block_extend_a_range(*active_range(document)); // 2. Let element list be a list of all editable Elements contained in new range that either has an attribute in the // HTML namespace whose local name is "align", or has a style attribute that sets "text-align", or is a center. Vector> element_list; new_range->for_each_contained([&element_list](GC::Ref node) { if (!node->is_editable() || !is(*node)) return IterationDecision::Continue; auto& element = static_cast(*node); if (element.has_attribute_ns(Namespace::HTML, HTML::AttributeNames::align) || property_in_style_attribute(element, CSS::PropertyID::TextAlign) || element.local_name() == HTML::TagNames::center) element_list.append(element); return IterationDecision::Continue; }); // 3. For each element in element list: for (auto element : element_list) { // 1. If element has an attribute in the HTML namespace whose local name is "align", remove that attribute. if (element->has_attribute_ns(Namespace::HTML, HTML::AttributeNames::align)) element->remove_attribute_ns(Namespace::HTML, HTML::AttributeNames::align); // 2. Unset the CSS property "text-align" on element, if it's set by a style attribute. auto inline_style = element->style_for_bindings(); MUST(inline_style->remove_property(CSS::PropertyID::TextAlign)); // 3. If element is a div or span or center with no attributes, remove it, preserving its descendants. if (element->local_name().is_one_of(HTML::TagNames::div, HTML::TagNames::span, HTML::TagNames::center) && !element->has_attributes()) remove_node_preserving_its_descendants(element); // 4. If element is a center with one or more attributes, set the tag name of element to "div". if (element->local_name() == HTML::TagNames::center && element->has_attributes()) set_the_tag_name(element, HTML::TagNames::div); } // 4. Block-extend the active range, and let new range be the result. new_range = block_extend_a_range(*active_range(document)); // 5. Let node list be a list of nodes, initially empty. Vector> node_list; // 6. For each node node contained in new range, append node to node list if the last member of node list (if any) // is not an ancestor of node; node is editable; node is an allowed child of "div"; and node's alignment value is // not alignment. new_range->for_each_contained([&](GC::Ref node) { if ((node_list.is_empty() || !node_list.last()->is_ancestor_of(node)) && node->is_editable() && is_allowed_child_of_node(node, HTML::TagNames::div) && alignment_value_of_node(node) != alignment) node_list.append(node); return IterationDecision::Continue; }); // 7. While node list is not empty: while (!node_list.is_empty()) { // 1. Let sublist be a list of nodes, initially empty. Vector> sublist; // 2. Remove the first member of node list and append it to sublist. sublist.append(node_list.take_first()); // 3. While node list is not empty, and the first member of node list is the nextSibling of the last member of // sublist, remove the first member of node list and append it to sublist. while (!node_list.is_empty() && node_list.first().ptr() == sublist.last()->next_sibling()) sublist.append(node_list.take_first()); // 4. Wrap sublist. Sibling criteria returns true for any div that has one or both of the following two // attributes and no other attributes, and false otherwise: // * An align attribute whose value is an ASCII case-insensitive match for alignment. // * A style attribute which sets exactly one CSS property (including unrecognized or invalid attributes), // which is "text-align", which is set to alignment. // // New parent instructions are to call createElement("div") on the context object, then set its CSS property // "text-align" to alignment and return the result. auto alignment_keyword = string_from_keyword([&alignment] { switch (alignment) { case JustifyAlignment::Center: return CSS::Keyword::Center; case JustifyAlignment::Justify: return CSS::Keyword::Justify; case JustifyAlignment::Left: return CSS::Keyword::Left; case JustifyAlignment::Right: return CSS::Keyword::Right; } VERIFY_NOT_REACHED(); }()); wrap( sublist, [&](GC::Ref sibling) { if (!is(*sibling)) return false; GC::Ref element = static_cast(*sibling); u8 number_of_matching_attributes = 0; if (element->get_attribute_value(HTML::AttributeNames::align).equals_ignoring_ascii_case(alignment_keyword)) ++number_of_matching_attributes; if (element->has_attribute(HTML::AttributeNames::style) && element->inline_style() && element->inline_style()->length() == 1) { if (auto text_align = element->inline_style()->get_property_style_value(CSS::PropertyID::TextAlign)) { auto align_value = text_align->to_string(CSS::SerializationMode::Normal); if (align_value.equals_ignoring_ascii_case(alignment_keyword)) ++number_of_matching_attributes; } } return element->attribute_list_size() == number_of_matching_attributes; }, [&] { auto div = MUST(DOM::create_element(document, HTML::TagNames::div, Namespace::HTML)); auto inline_style = div->style_for_bindings(); MUST(inline_style->set_property(CSS::PropertyID::TextAlign, alignment_keyword)); return div; }); } } // https://w3c.github.io/editing/docs/execCommand/#last-equivalent-point DOM::BoundaryPoint last_equivalent_point(DOM::BoundaryPoint boundary_point) { // 1. While (node, offset)'s next equivalent point is not null, set (node, offset) to its next equivalent point. while (true) { auto next_point = next_equivalent_point(boundary_point); if (!next_point.has_value()) break; boundary_point = next_point.release_value(); } // 2. Return (node, offset). return boundary_point; } // https://w3c.github.io/editing/docs/execCommand/#legacy-font-size-for Utf16String legacy_font_size(int pixel_size) { // 1. Let returned size be 1. int returned_size = 1; // 2. While returned size is less than 7: while (returned_size < 7) { // 1. Let lower bound be the resolved value of "font-size" in pixels of a font element whose size attribute is // set to returned size. auto lower_bound = font_size_to_pixel_size(Utf16String::number(returned_size)).to_float(); // 2. Let upper bound be the resolved value of "font-size" in pixels of a font element whose size attribute is // set to one plus returned size. auto upper_bound = font_size_to_pixel_size(Utf16String::number(returned_size + 1)).to_float(); // 3. Let average be the average of upper bound and lower bound. auto average = (lower_bound + upper_bound) / 2; // 4. If pixel size is less than average, return the one-code unit string consisting of the digit returned size. if (pixel_size < average) return Utf16String::number(returned_size); // 5. Add one to returned size. ++returned_size; } // 3. Return "7". return "7"_utf16; } // https://w3c.github.io/editing/docs/execCommand/#preserving-ranges void move_node_preserving_ranges(GC::Ref node, GC::Ref new_parent, u32 new_index) { // To move a node to a new location, preserving ranges, remove the node from its original parent // (if any), then insert it in the new location. In doing so, follow these rules instead of // those defined by the insert and remove algorithms: // AD-HOC: We implement this spec by taking note of the current active range (if any), performing the remove and // insertion of node, and then restoring the range after performing any necessary adjustments. Optional start; Optional end; auto range = active_range(node->document()); if (range) { start = range->start(); end = range->end(); } // 1. Let node be the moved node, old parent and old index be the old parent (which may be null) // and index, and new parent and new index be the new parent and index. auto* old_parent = node->parent(); auto old_index = node->index(); if (old_parent) node->remove(); auto* new_next_sibling = new_parent->child_at_index(new_index); new_parent->insert_before(node, new_next_sibling); // AD-HOC: Return early if there was no active range if (!range) return; // 2. If a boundary point's node is the same as or a descendant of node, leave it unchanged, so // it moves to the new location. // NOTE: This step exists for completeness. // 3. If a boundary point's node is new parent and its offset is greater than new index, add one // to its offset. if (start->node == new_parent && start->offset > new_index) start->offset++; if (end->node == new_parent && end->offset > new_index) end->offset++; // 4. If a boundary point's node is old parent and its offset is old index or old index + 1, set // its node to new parent and add new index − old index to its offset. if (start->node == old_parent && (start->offset == old_index || start->offset == old_index + 1)) { start->node = new_parent; start->offset += new_index - old_index; } if (end->node == old_parent && (end->offset == old_index || end->offset == old_index + 1)) { end->node = new_parent; end->offset += new_index - old_index; } // 5. If a boundary point's node is old parent and its offset is greater than old index + 1, // subtract one from its offset. if (start->node == old_parent && start->offset > old_index + 1) start->offset--; if (end->node == old_parent && end->offset > old_index + 1) end->offset--; // AD-HOC: Set the new active range MUST(range->set_start(start->node, start->offset)); MUST(range->set_end(end->node, end->offset)); } // https://w3c.github.io/editing/docs/execCommand/#next-equivalent-point Optional next_equivalent_point(DOM::BoundaryPoint boundary_point) { // 1. If node's length is zero, return null. auto node = boundary_point.node; auto node_length = node->length(); if (node_length == 0) return {}; // 3. If offset is node's length, and node's parent is not null, and node is an inline node, return (node's parent, // 1 + node's index). if (boundary_point.offset == node_length && node->parent() && is_inline_node(*node)) return DOM::BoundaryPoint { *node->parent(), static_cast(node->index() + 1) }; // 5. If node has a child with index offset, and that child's length is not zero, and that child is an inline node, // return (that child, 0). auto child_at_offset = node->child_at_index(boundary_point.offset); if (child_at_offset && child_at_offset->length() != 0 && is_inline_node(*child_at_offset)) return DOM::BoundaryPoint { *child_at_offset, 0 }; // 7. Return null. return {}; } // https://w3c.github.io/editing/docs/execCommand/#normalize-sublists void normalize_sublists_in_node(GC::Ref item) { // 1. If item is not an li or it is not editable or its parent is not editable, abort these // steps. if (!is(*item) || !item->is_editable() || !item->parent()->is_editable()) return; // 2. Let new item be null. GC::Ptr new_item; // 3. While item has an ol or ul child: while (item->has_child_of_type() || item->has_child_of_type()) { // 1. Let child be the last child of item. GC::Ref child = *item->last_child(); // 2. If child is an ol or ul, or new item is null and child is a Text node whose data // consists of zero of more space characters: auto child_text = child->text_content(); auto text_is_all_whitespace = child_text.has_value() && all_of(*child_text, Infra::is_ascii_whitespace); if ((is(*child) || is(*child)) || (!new_item && is(*child) && text_is_all_whitespace)) { // 1. Set new item to null. new_item = {}; // 2. Insert child into the parent of item immediately following item, preserving // ranges. move_node_preserving_ranges(child, *item->parent(), item->index()); } // 3. Otherwise: else { // 1. If new item is null, let new item be the result of calling createElement("li") on // the ownerDocument of item, then insert new item into the parent of item // immediately after item. if (!new_item) { new_item = MUST(DOM::create_element(*item->owner_document(), HTML::TagNames::li, Namespace::HTML)); item->parent()->insert_before(*new_item, item->next_sibling()); } // 2. Insert child into new item as its first child, preserving ranges. move_node_preserving_ranges(child, *new_item, 0); } } } // https://w3c.github.io/editing/docs/execCommand/#outdent void outdent(GC::Ref node) { // 1. If node is not editable, abort these steps. if (!node->is_editable()) return; // 2. If node is a simple indentation element, remove node, preserving its descendants. Then abort these steps. if (is_simple_indentation_element(node)) { remove_node_preserving_its_descendants(node); return; } // 3. If node is an indentation element: if (is_indentation_element(node)) { // 1. Unset the dir attribute of node, if any. auto& element = static_cast(*node); element.remove_attribute(HTML::AttributeNames::dir); // 2. Unset the margin, padding, and border CSS properties of node. if (auto inline_style = element.inline_style()) { MUST(inline_style->remove_property(CSS::PropertyID::Border)); MUST(inline_style->remove_property(CSS::PropertyID::Margin)); MUST(inline_style->remove_property(CSS::PropertyID::Padding)); } // 3. Set the tag name of node to "div". set_the_tag_name(element, HTML::TagNames::div); // 4. Abort these steps. return; } // 4. Let current ancestor be node's parent. GC::Ptr current_ancestor = node->parent(); // 5. Let ancestor list be a list of nodes, initially empty. Vector> ancestor_list; // 6. While current ancestor is an editable Element that is neither a simple indentation element nor an ol nor a ul, // append current ancestor to ancestor list and then set current ancestor to its parent. while (is(current_ancestor.ptr()) && current_ancestor->is_editable() && !is_simple_indentation_element(*current_ancestor) && !is(*current_ancestor) && !is(*current_ancestor)) { ancestor_list.append(*current_ancestor); current_ancestor = current_ancestor->parent(); } // 7. If current ancestor is not an editable simple indentation element: if (!current_ancestor || !current_ancestor->is_editable() || !is_simple_indentation_element(*current_ancestor)) { // 1. Let current ancestor be node's parent. current_ancestor = node->parent(); // 2. Let ancestor list be the empty list. ancestor_list.clear_with_capacity(); // 3. While current ancestor is an editable Element that is neither an indentation element nor an ol nor a ul, // append current ancestor to ancestor list and then set current ancestor to its parent. while (is(current_ancestor.ptr()) && current_ancestor->is_editable() && !is_indentation_element(*current_ancestor) && !is(*current_ancestor) && !is(*current_ancestor)) { ancestor_list.append(*current_ancestor); current_ancestor = current_ancestor->parent(); } } // 8. If node is an ol or ul and current ancestor is not an editable indentation element: if ((is(*node) || is(*node)) && !(current_ancestor->is_editable() && is_indentation_element(*current_ancestor))) { // 1. Unset the reversed, start, and type attributes of node, if any are set. auto& node_element = static_cast(*node); node_element.remove_attribute(HTML::AttributeNames::reversed); node_element.remove_attribute(HTML::AttributeNames::start); node_element.remove_attribute(HTML::AttributeNames::type); // 2. Let children be the children of node. Vector> children; for (auto* child = node->first_child(); child; child = child->next_sibling()) children.append(*child); // 3. If node has attributes, and its parent is not an ol or ul, set the tag name of node to "div". if (node_element.has_attributes() && !is(node->parent()) && !is(node->parent())) { set_the_tag_name(node_element, HTML::TagNames::div); } // 4. Otherwise: else { // 1. Record the values of node's children, and let values be the result. auto values = record_the_values_of_nodes(node->heap(), children); // 2. Remove node, preserving its descendants. remove_node_preserving_its_descendants(node); // 3. Restore the values from values. restore_the_values_of_nodes(values); } // 5. Fix disallowed ancestors of each member of children. for (auto child : children) fix_disallowed_ancestors_of_node(*child); // 6. Abort these steps. return; } // 9. If current ancestor is not an editable indentation element, abort these steps. if (!current_ancestor || !current_ancestor->is_editable() || !is_indentation_element(*current_ancestor)) return; // 10. Append current ancestor to ancestor list. ancestor_list.append(*current_ancestor); // 11. Let original ancestor be current ancestor. auto original_ancestor = current_ancestor; // 12. While ancestor list is not empty: while (!ancestor_list.is_empty()) { // 1. Let current ancestor be the last member of ancestor list. // 2. Remove the last member from ancestor list. current_ancestor = ancestor_list.take_last(); // 3. Let target be the child of current ancestor that is equal to either node or the last member of ancestor // list. GC::Ptr target; for (auto* child = current_ancestor->first_child(); child; child = child->next_sibling()) { if (child == node.ptr() || (!ancestor_list.is_empty() && child == ancestor_list.last().ptr())) { target = child; break; } } VERIFY(target); // 4. If target is an inline node that is not a br, and its nextSibling is a br, remove target's nextSibling // from its parent. if (is_inline_node(*target) && !is(*target) && is(target->next_sibling())) target->next_sibling()->remove(); // 5. Let preceding siblings be the precedings siblings of target, and let following siblings be the followings // siblings of target. Vector> preceding_siblings; for (auto* sibling = target->previous_sibling(); sibling; sibling = sibling->previous_sibling()) preceding_siblings.append(*sibling); Vector> following_siblings; for (auto* sibling = target->next_sibling(); sibling; sibling = sibling->next_sibling()) following_siblings.append(*sibling); // 6. Indent preceding siblings. indent(preceding_siblings); // 7. Indent following siblings. indent(following_siblings); } // 13. Outdent original ancestor. outdent(*original_ancestor); } // https://w3c.github.io/editing/docs/execCommand/#precedes-a-line-break bool precedes_a_line_break(GC::Ref node) { // 1. Let offset be node's length. WebIDL::UnsignedLong offset = node->length(); // 2. While (node, offset) is not a block boundary point: while (!is_block_boundary_point({ node, offset })) { // 1. If node has a visible child with index offset, return false. auto* offset_child = node->child_at_index(offset); if (offset_child && is_visible_node(*offset_child)) return false; // 2. If offset is node's length or node has no children, set offset to one plus node's // index, then set node to its parent. if (offset == node->length() || node->child_count() == 0) { offset = node->index() + 1; node = *node->parent(); } // 3. Otherwise, set node to its child with index offset and set offset to zero. else { node = *node->child_at_index(offset); offset = 0; } } // 3. Return true; return true; } // https://w3c.github.io/editing/docs/execCommand/#previous-equivalent-point Optional previous_equivalent_point(DOM::BoundaryPoint boundary_point) { // 1. If node's length is zero, return null. auto node = boundary_point.node; auto node_length = node->length(); if (node_length == 0) return {}; // 2. If offset is 0, and node's parent is not null, and node is an inline node, return (node's parent, node's // index). if (boundary_point.offset == 0 && node->parent() && is_inline_node(*node)) return DOM::BoundaryPoint { *node->parent(), static_cast(node->index()) }; // 3. If node has a child with index offset − 1, and that child's length is not zero, and that child is an inline // node, return (that child, that child's length). auto child_at_offset = node->child_at_index(boundary_point.offset - 1); if (child_at_offset && child_at_offset->length() != 0 && is_inline_node(*child_at_offset)) return DOM::BoundaryPoint { *child_at_offset, static_cast(child_at_offset->length()) }; // 4. Return null. return {}; } // https://w3c.github.io/editing/docs/execCommand/#push-down-values void push_down_values(FlyString const& command, GC::Ref node, Optional new_value) { // 1. Let command be the current command. // 2. If node's parent is not an Element, abort this algorithm. if (!is(node->parent())) return; // 3. If the effective command value of command is loosely equivalent to new value on node, abort this algorithm. if (values_are_loosely_equivalent(command, effective_command_value(node, command), new_value)) return; // 4. Let current ancestor be node's parent. auto current_ancestor = GC::Ptr { node->parent() }; // 5. Let ancestor list be a list of nodes, initially empty. Vector> ancestor_list; // 6. While current ancestor is an editable Element and the effective command value of command is not loosely // equivalent to new value on it, append current ancestor to ancestor list, then set current ancestor to its // parent. while (is(current_ancestor.ptr()) && current_ancestor->is_editable() && !values_are_loosely_equivalent(command, effective_command_value(current_ancestor, command), new_value)) { ancestor_list.append(*current_ancestor); current_ancestor = current_ancestor->parent(); } // 7. If ancestor list is empty, abort this algorithm. if (ancestor_list.is_empty()) return; // 8. Let propagated value be the specified command value of command on the last member of ancestor list. auto propagated_value = specified_command_value(static_cast(*ancestor_list.last()), command); // 9. If propagated value is null and is not equal to new value, abort this algorithm. if (!propagated_value.has_value() && new_value.has_value()) return; // 10. If the effective command value of command is not loosely equivalent to new value on the parent of the last // member of ancestor list, and new value is not null, abort this algorithm. if (new_value.has_value() && ancestor_list.last()->parent() && !values_are_loosely_equivalent(command, effective_command_value(ancestor_list.last()->parent(), command), new_value)) return; // 11. While ancestor list is not empty: while (!ancestor_list.is_empty()) { // 1. Let current ancestor be the last member of ancestor list. // 2. Remove the last member from ancestor list. current_ancestor = ancestor_list.take_last(); // 3. If the specified command value of current ancestor for command is not null, set propagated value to that // value. // NOTE: Step 6 above guarantees that current_ancestor is an Element. auto command_value = specified_command_value(static_cast(*current_ancestor), command); if (command_value.has_value()) propagated_value = command_value.value(); // 4. Let children be the children of current ancestor. auto children = current_ancestor->children_as_vector(); // 5. If the specified command value of current ancestor for command is not null, clear the value of current // ancestor. if (command_value.has_value()) clear_the_value(command, static_cast(*current_ancestor)); // 6. For every child in children: for (auto const& child : children) { // 1. If child is node, continue with the next child. if (child.ptr() == node.ptr()) continue; // 2. If child is an Element whose specified command value for command is neither null nor equivalent to // propagated value, continue with the next child. if (is(*child)) { auto child_command_value = specified_command_value(static_cast(*child), command); if (child_command_value.has_value() && child_command_value != propagated_value) continue; } // 3. If child is the last member of ancestor list, continue with the next child. if (!ancestor_list.is_empty() && child.ptr() == ancestor_list.last().ptr()) continue; // 4. Force the value of child, with command as in this algorithm and new value equal to propagated value. force_the_value(*child, command, propagated_value); } } } // https://w3c.github.io/editing/docs/execCommand/#record-current-overrides Vector record_current_overrides(DOM::Document const& document) { // 1. Let overrides be a list of (string, string or boolean) ordered pairs, initially empty. Vector overrides; // 2. If there is a value override for "createLink", add ("createLink", value override for "createLink") to // overrides. if (auto override = document.command_value_override(CommandNames::createLink); override.has_value()) overrides.empend(CommandNames::createLink, override.release_value()); // 3. For each command in the list "bold", "italic", "strikethrough", "subscript", "superscript", "underline", in // order: if there is a state override for command, add (command, command's state override) to overrides. for (auto const& command : { CommandNames::bold, CommandNames::italic, CommandNames::strikethrough, CommandNames::subscript, CommandNames::superscript, CommandNames::underline }) { if (auto override = document.command_state_override(command); override.has_value()) overrides.empend(command, override.release_value()); } // 4. For each command in the list "fontName", "fontSize", "foreColor", "hiliteColor", in order: if there is a value // override for command, add (command, command's value override) to overrides. for (auto const& command : { CommandNames::fontName, CommandNames::fontSize, CommandNames::foreColor, CommandNames::hiliteColor }) { if (auto override = document.command_value_override(command); override.has_value()) overrides.empend(command, override.release_value()); } // 5. Return overrides. return overrides; } // https://w3c.github.io/editing/docs/execCommand/#record-current-states-and-values Vector record_current_states_and_values(DOM::Document const& document) { // 1. Let overrides be a list of (string, string or boolean) ordered pairs, initially empty. Vector overrides; // 2. Let node be the first formattable node effectively contained in the active range, or null if there is none. auto node = first_formattable_node_effectively_contained(active_range(document)); // 3. If node is null, return overrides. if (!node) return overrides; // 4. Add ("createLink", node's effective command value for "createLink") to overrides. auto effective_value = effective_command_value(node, CommandNames::createLink); if (effective_value.has_value()) overrides.empend(CommandNames::createLink, effective_value.release_value()); // 5. For each command in the list "bold", "italic", "strikethrough", "subscript", "superscript", "underline", in // order: if node's effective command value for command is one of its inline command activated values, add // (command, true) to overrides, and otherwise add (command, false) to overrides. for (auto const& command : { CommandNames::bold, CommandNames::italic, CommandNames::strikethrough, CommandNames::subscript, CommandNames::superscript, CommandNames::underline }) { effective_value = effective_command_value(node, command); auto& inline_activated_values = find_command_definition(command)->inline_activated_values; overrides.empend(command, effective_value.has_value() && inline_activated_values.contains_slow(*effective_value)); } // 6. For each command in the list "fontName", "foreColor", "hiliteColor", in order: add (command, command's value) // to overrides. for (auto const& command : { CommandNames::fontName, CommandNames::foreColor, CommandNames::hiliteColor }) overrides.empend(command, Utf16String::from_utf8_without_validation(MUST(node->document().query_command_value(command)))); // 7. Add ("fontSize", node's effective command value for "fontSize") to overrides. effective_value = effective_command_value(node, CommandNames::fontSize); if (effective_value.has_value()) overrides.empend(CommandNames::fontSize, effective_value.release_value()); // 8. Return overrides. return overrides; } // https://w3c.github.io/editing/docs/execCommand/#record-the-values GC::ConservativeVector record_the_values_of_nodes(GC::Heap& heap, Vector> const& node_list) { // 1. Let values be a list of (node, command, specified command value) triples, initially empty. GC::ConservativeVector values { heap }; // 2. For each node in node list, for each command in the list "subscript", "bold", "fontName", // "fontSize", "foreColor", "hiliteColor", "italic", "strikethrough", and "underline" in that // order: // AD-HOC: We include "preserveWhitespace" as well. Array const commands = { CommandNames::subscript, CommandNames::bold, CommandNames::fontName, CommandNames::fontSize, CommandNames::foreColor, CommandNames::hiliteColor, CommandNames::italic, CommandNames::strikethrough, CommandNames::underline, CommandNames::preserveWhitespace }; for (auto node : node_list) { for (auto command : commands) { // 1. Let ancestor equal node. auto ancestor = node; // 2. If ancestor is not an Element, set it to its parent. if (!is(*ancestor)) ancestor = *ancestor->parent(); // 3. While ancestor is an Element and its specified command value for command is null, set // it to its parent. while (is(*ancestor) && !specified_command_value(static_cast(*ancestor), command).has_value()) ancestor = *ancestor->parent(); // 4. If ancestor is an Element, add (node, command, ancestor's specified command value for // command) to values. Otherwise add (node, command, null) to values. if (is(*ancestor)) values.empend(*node, command, specified_command_value(static_cast(*ancestor), command)); else values.empend(*node, command, OptionalNone {}); } } // 3. Return values. return values; } // https://w3c.github.io/editing/docs/execCommand/#remove-extraneous-line-breaks-at-the-end-of void remove_extraneous_line_breaks_at_the_end_of_node(GC::Ref node) { // 1. Let ref be node. GC::Ptr ref = node; // 2. While ref has children, set ref to its lastChild. while (ref->child_count() > 0) ref = ref->last_child(); // 3. While ref is invisible but not an extraneous line break, and ref does not equal node, set // ref to the node before it in tree order. while (is_invisible_node(*ref) && !is_extraneous_line_break(*ref) && ref != node) { ref = ref->previous_in_pre_order(); } // 4. If ref is an editable extraneous line break: if (ref->is_editable() && is_extraneous_line_break(*ref)) { // 1. While ref's parent is editable and invisible, set ref to its parent. while (ref->parent()->is_editable() && is_invisible_node(*ref->parent())) ref = ref->parent(); // 2. Remove ref from its parent. ref->remove(); } } // https://w3c.github.io/editing/docs/execCommand/#remove-extraneous-line-breaks-before void remove_extraneous_line_breaks_before_node(GC::Ref node) { // 1. Let ref be the previousSibling of node. GC::Ptr ref = node->previous_sibling(); // 2. If ref is null, abort these steps. if (!ref) return; // 3. While ref has children, set ref to its lastChild. while (ref->child_count() > 0) ref = ref->last_child(); // 4. While ref is invisible but not an extraneous line break, and ref does not equal node's // parent, set ref to the node before it in tree order. while (is_invisible_node(*ref) && !is_extraneous_line_break(*ref) && ref != node->parent()) { ref = ref->previous_in_pre_order(); } // 5. If ref is an editable extraneous line break, remove it from its parent. if (ref->is_editable() && is_extraneous_line_break(*ref)) ref->remove(); } // https://w3c.github.io/editing/docs/execCommand/#remove-extraneous-line-breaks-from void remove_extraneous_line_breaks_from_a_node(GC::Ref node) { // To remove extraneous line breaks from a node, first remove extraneous line breaks before it, // then remove extraneous line breaks at the end of it. remove_extraneous_line_breaks_before_node(node); remove_extraneous_line_breaks_at_the_end_of_node(node); } // https://w3c.github.io/editing/docs/execCommand/#preserving-its-descendants void remove_node_preserving_its_descendants(GC::Ref node) { // To remove a node node while preserving its descendants, split the parent of node's children if it has any. if (node->has_children()) { Vector> children; children.ensure_capacity(node->child_count()); for (auto* child = node->first_child(); child; child = child->next_sibling()) children.append(*child); split_the_parent_of_nodes(children); return; } // If it has no children, instead remove it from its parent. node->remove(); } // https://w3c.github.io/editing/docs/execCommand/#reorder-modifiable-descendants void reorder_modifiable_descendants(GC::Ref node, FlyString const& command, Optional new_value) { // 1. Let candidate equal node. GC::Ptr candidate = node; // 2. While candidate is a modifiable element, and candidate has exactly one child, and that child is also a // modifiable element, and candidate is not a simple modifiable element or candidate's specified command value // for command is not equivalent to new value, set candidate to its child. while (is_modifiable_element(*candidate) && candidate->child_count() == 1 && is_modifiable_element(*candidate->first_child()) && (!is_simple_modifiable_element(*candidate) || specified_command_value(static_cast(*candidate), command) != new_value)) { candidate = candidate->first_child(); } // 3. If candidate is node, or is not a simple modifiable element, or its specified command value is not equivalent // to new value, or its effective command value is not loosely equivalent to new value, abort these steps. if (candidate == node || !is_simple_modifiable_element(*candidate) || specified_command_value(static_cast(*candidate), command) != new_value || !values_are_loosely_equivalent(command, effective_command_value(candidate, command), new_value)) return; // 4. While candidate has children, insert the first child of candidate into candidate's parent immediately before // candidate, preserving ranges. while (candidate->has_children()) move_node_preserving_ranges(*candidate->first_child(), *candidate->parent(), candidate->index()); // 5. Insert candidate into node's parent immediately after node. if (node->next_sibling()) node->parent()->insert_before(*candidate, node->next_sibling()); else MUST(node->parent()->append_child(*candidate)); // 6. Append the node as the last child of candidate, preserving ranges. move_node_preserving_ranges(node, *candidate, candidate->child_count()); } // https://w3c.github.io/editing/docs/execCommand/#restore-states-and-values void restore_states_and_values(DOM::Document& document, Vector const& overrides) { // 1. Let node be the first formattable node effectively contained in the active range, or null if there is none. auto node = first_formattable_node_effectively_contained(active_range(document)); // 2. If node is not null, if (node) { // then for each (command, override) pair in overrides, in order: for (auto override : overrides) { // 1. If override is a boolean, and queryCommandState(command) returns something different from override, // take the action for command, with value equal to the empty string. if (override.value.has() && MUST(document.query_command_state(override.command)) != override.value.get()) { take_the_action_for_command(document, override.command, {}); } // 2. Otherwise, if override is a string, and command is neither "createLink" nor "fontSize", and // queryCommandValue(command) returns something not equivalent to override, take the action for command, // with value equal to override. else if (override.value.has() && !override.command.is_one_of(CommandNames::createLink, CommandNames::fontSize) && MUST(document.query_command_value(override.command)) != override.value.get()) { take_the_action_for_command(document, override.command, override.value.get()); } // 3. Otherwise, if override is a string; and command is "createLink"; and either there is a value override // for "createLink" that is not equal to override, or there is no value override for "createLink" and // node's effective command value for "createLink" is not equal to override: take the action for // "createLink", with value equal to override. else if (auto value_override = document.command_value_override(CommandNames::createLink); override.value.has() && override.command == CommandNames::createLink && ((value_override.has_value() && value_override.value() != override.value.get()) || (!value_override.has_value() && effective_command_value(node, CommandNames::createLink) != override.value.get()))) { take_the_action_for_command(document, CommandNames::createLink, override.value.get()); } // 4. Otherwise, if override is a string; and command is "fontSize"; and either there is a value override // for "fontSize" that is not equal to override, or there is no value override for "fontSize" and node's // effective command value for "fontSize" is not loosely equivalent to override: else if (auto value_override = document.command_value_override(CommandNames::fontSize); override.value.has() && override.command == CommandNames::fontSize && ((value_override.has_value() && value_override.value() != override.value.get()) || (!value_override.has_value() && !values_are_loosely_equivalent( CommandNames::fontSize, effective_command_value(node, CommandNames::fontSize), override.value.get())))) { // 1. Convert override to an integer number of pixels, and set override to the legacy font size for the // result. auto override_pixel_size = font_size_to_pixel_size(override.value.get()); override.value = legacy_font_size(override_pixel_size.to_int()); // 2. Take the action for "fontSize", with value equal to override. take_the_action_for_command(document, CommandNames::fontSize, override.value.get()); } // 5. Otherwise, continue this loop from the beginning. else { continue; } // 6. Set node to the first formattable node effectively contained in the active range, if there is one. if (auto new_formattable_node = first_formattable_node_effectively_contained(active_range(document))) node = new_formattable_node; } } // 3. Otherwise, for each (command, override) pair in overrides, in order: else { for (auto const& override : overrides) { // 1. If override is a boolean, set the state override for command to override. // 2. If override is a string, set the value override for command to override. override.value.visit( [&](bool value) { document.set_command_state_override(override.command, value); }, [&](Utf16String const& value) { document.set_command_value_override(override.command, value); }); } } } // https://w3c.github.io/editing/docs/execCommand/#restore-the-values void restore_the_values_of_nodes(Vector const& values) { // 1. For each (node, command, value) triple in values: for (auto const& recorded_node_value : values) { auto node = recorded_node_value.node; auto const& command = recorded_node_value.command; auto value = recorded_node_value.specified_command_value; // 1. Let ancestor equal node. GC::Ptr ancestor = node; // 2. If ancestor is not an Element, set it to its parent. if (!is(*ancestor)) ancestor = ancestor->parent(); // 3. While ancestor is an Element and its specified command value for command is null, set it to its parent. while (is(ancestor.ptr()) && !specified_command_value(static_cast(*ancestor), command).has_value()) ancestor = ancestor->parent(); // 4. If value is null and ancestor is an Element, push down values on node for command, with new value null. if (!value.has_value() && is(ancestor.ptr())) { push_down_values(command, node, {}); } // 5. Otherwise, if ancestor is an Element and its specified command value for command is not equivalent to // value, or if ancestor is not an Element and value is not null, force the value of command to value on // node. else if ((is(ancestor.ptr()) && specified_command_value(static_cast(*ancestor), command) != value) || (!is(ancestor.ptr()) && value.has_value())) { force_the_value(node, command, value); } } } // https://w3c.github.io/editing/docs/execCommand/#selection's-list-state SelectionsListState selections_list_state(DOM::Document const& document) { // 1. If the active range is null, return "none". auto range = active_range(document); if (!range) return SelectionsListState::None; // 2. Block-extend the active range, and let new range be the result. auto new_range = block_extend_a_range(*range); // 3. Let node list be a list of nodes, initially empty. Vector> node_list; // 4. For each node contained in new range, append node to node list if the last member of node list (if any) is not // an ancestor of node; node is editable; node is not an indentation element; and node is either an ol or ul, or // the child of an ol or ul, or an allowed child of "li". new_range->for_each_contained([&node_list](GC::Ref node) { if ((node_list.is_empty() || !node_list.last()->is_ancestor_of(node)) && node->is_editable() && !is_indentation_element(node) && ((is(*node) || is(*node)) || (is(node->parent()) || is(node->parent())) || is_allowed_child_of_node(node, HTML::TagNames::li))) node_list.append(node); return IterationDecision::Continue; }); // 5. If node list is empty, return "none". if (node_list.is_empty()) return SelectionsListState::None; // 6. If every member of node list is either an ol or the child of an ol or the child of an li child of an ol, and // none is a ul or an ancestor of a ul, return "ol". auto is_ancestor_of_type = [](GC::Ref node) { bool has_type = false; node->for_each_in_subtree([&has_type](GC::Ref descendant) { if (is(*descendant)) { has_type = true; return TraversalDecision::Break; } return TraversalDecision::Continue; }); return has_type; }; auto is_type_or_child_of_list_type = [](GC::Ref node) { return is(*node) || is(node->parent()) || (is(node->parent()) && is(node->parent()->parent())); }; auto is_type_or_child_or_ancestor_of_list_type = [&](GC::Ref node) { return is_type_or_child_of_list_type.operator()(node) || is_ancestor_of_type.operator()(node); }; bool all_is_an_ol = true; bool none_is_a_ul = true; for (auto node : node_list) { if (!is_type_or_child_of_list_type.operator()(*node)) { all_is_an_ol = false; break; } if (is(*node) || is_ancestor_of_type.operator()(node)) { none_is_a_ul = false; break; } } if (all_is_an_ol && none_is_a_ul) return SelectionsListState::Ol; // 7. If every member of node list is either a ul or the child of a ul or the child of an li child of a ul, and none // is an ol or an ancestor of an ol, return "ul". bool all_is_a_ul = true; bool none_is_an_ol = true; for (auto node : node_list) { if (!is_type_or_child_of_list_type.operator()(*node)) { all_is_a_ul = false; break; } if (is(*node) || is_ancestor_of_type.operator()(node)) { none_is_an_ol = false; break; } } if (all_is_a_ul && none_is_an_ol) return SelectionsListState::Ul; // 8. If some member of node list is either an ol or the child or ancestor of an ol or the child of an li child of // an ol, and some member of node list is either a ul or the child or ancestor of a ul or the child of an li // child of a ul, return "mixed". bool any_is_ol = false; bool any_is_ul = false; for (auto node : node_list) { if (is_type_or_child_or_ancestor_of_list_type.operator()(*node)) any_is_ol = true; if (is_type_or_child_or_ancestor_of_list_type.operator()(*node)) any_is_ul = true; if (any_is_ol && any_is_ul) break; } if (any_is_ol && any_is_ul) return SelectionsListState::Mixed; // 9. If some member of node list is either an ol or the child or ancestor of an ol or the child of an li child of // an ol, return "mixed ol". if (any_is_ol) return SelectionsListState::MixedOl; // 10. If some member of node list is either a ul or the child or ancestor of a ul or the child of an li child of a // ul, return "mixed ul". if (any_is_ul) return SelectionsListState::MixedUl; // 11. Return "none". return SelectionsListState::None; } // https://w3c.github.io/editing/docs/execCommand/#set-the-selection's-value void set_the_selections_value(DOM::Document& document, FlyString const& command, Optional new_value) { // 1. Let command be the current command. // 2. If there is no formattable node effectively contained in the active range: auto has_matching_node = false; for_each_node_effectively_contained_in_range(active_range(document), [&](GC::Ref descendant) { if (is_formattable_node(descendant)) { has_matching_node = true; return TraversalDecision::Break; } return TraversalDecision::Continue; }); if (!has_matching_node) { // 1. If command has inline command activated values, set the state override to true if new value is among them // and false if it's not. auto command_definition = find_command_definition(command); if (!command_definition->inline_activated_values.is_empty()) { auto new_override = new_value.has_value() && command_definition->inline_activated_values.contains_slow(*new_value); document.set_command_state_override(command, new_override); } // 2. If command is "subscript", unset the state override for "superscript". if (command == CommandNames::subscript) document.clear_command_state_override(CommandNames::superscript); // 3. If command is "superscript", unset the state override for "subscript". if (command == CommandNames::superscript) document.clear_command_state_override(CommandNames::subscript); // 4. If new value is null, unset the value override (if any). if (!new_value.has_value()) { document.clear_command_value_override(command); } // 5. Otherwise, if command is "createLink" or it has a value specified, set the value override to new value. else if (command == CommandNames::createLink || !MUST(document.query_command_value(CommandNames::createLink)).is_empty()) { document.set_command_value_override(command, *new_value); } // 6. Abort these steps. return; } // 3. If the active range's start node is an editable Text node, and its start offset is neither zero nor its start // node's length, call splitText() on the active range's start node, with argument equal to the active range's // start offset. Then set the active range's start node to the result, and its start offset to zero. auto range = active_range(document); auto start = range->start(); if (start.node->is_editable() && is(*start.node) && start.offset != 0 && start.offset != start.node->length()) { auto new_node = MUST(static_cast(*start.node).split_text(start.offset)); MUST(range->set_start(new_node, 0)); } // 4. If the active range's end node is an editable Text node, and its end offset is neither zero nor its end node's // length, call splitText() on the active range's end node, with argument equal to the active range's end offset. auto end = range->end(); if (end.node->is_editable() && is(*end.node) && end.offset != 0 && end.offset != end.node->length()) MUST(static_cast(*end.node).split_text(end.offset)); // 5. Let element list be all editable Elements effectively contained in the active range. Vector> element_list; for_each_node_effectively_contained_in_range(active_range(document), [&](GC::Ref descendant) { if (descendant->is_editable() && is(*descendant)) element_list.append(static_cast(*descendant)); return TraversalDecision::Continue; }); // 6. For each element in element list, clear the value of element. for (auto element : element_list) clear_the_value(command, element); // 7. Let node list be all editable nodes effectively contained in the active range. Vector> node_list; for_each_node_effectively_contained_in_range(active_range(document), [&](GC::Ref descendant) { if (descendant->is_editable()) node_list.append(descendant); return TraversalDecision::Continue; }); // 8. For each node in node list: for (auto node : node_list) { // 1. Push down values on node. push_down_values(command, node, new_value); // 2. If node is an allowed child of "span", force the value of node. if (is_allowed_child_of_node(node, HTML::TagNames::span)) force_the_value(node, command, new_value); } } // https://w3c.github.io/editing/docs/execCommand/#set-the-tag-name GC::Ref set_the_tag_name(GC::Ref element, FlyString const& new_name) { // 1. If element is an HTML element with local name equal to new name, return element. if (is(*element) && static_cast(element).local_name() == new_name) return element; // 2. If element's parent is null, return element. if (!element->parent()) return element; // 3. Let replacement element be the result of calling createElement(new name) on the ownerDocument of element. auto replacement_element = MUST(element->owner_document()->create_element(new_name.to_string(), Bindings::ElementCreationOptions {})); // 4. Insert replacement element into element's parent immediately before element. element->parent()->insert_before(replacement_element, element); // 5. Copy all attributes of element to replacement element, in order. element->for_each_attribute([&replacement_element](FlyString const& name, String const& value) { replacement_element->set_attribute_value(name, value); }); // 6. While element has children, append the first child of element as the last child of replacement element, preserving ranges. while (element->has_children()) move_node_preserving_ranges(*element->first_child(), *replacement_element, replacement_element->child_count()); // 7. Remove element from its parent. element->remove(); // 8. Return replacement element. return replacement_element; } // https://w3c.github.io/editing/docs/execCommand/#specified-command-value Optional specified_command_value(GC::Ref element, FlyString const& command) { // 1. If command is "backColor" or "hiliteColor" and the Element's display property does not have resolved value // "inline", return null. if (command.is_one_of(CommandNames::backColor, CommandNames::hiliteColor)) { auto display = resolved_display(element); if (!display.has_value() || !display->is_inline_outside() || !display->is_flow_inside()) return {}; } // 2. If command is "createLink" or "unlink": if (command.is_one_of(CommandNames::createLink, CommandNames::unlink)) { // 1. If element is an a element and has an href attribute, return the value of that attribute. auto href_attribute = element->get_attribute(HTML::AttributeNames::href); if (href_attribute.has_value()) return Utf16String::from_utf8_without_validation(href_attribute.release_value()); // 2. Return null. return {}; } // 3. If command is "subscript" or "superscript": if (command.is_one_of(CommandNames::subscript, CommandNames::superscript)) { // 1. If element is a sup, return "superscript". if (element->local_name() == HTML::TagNames::sup) return "superscript"_utf16; // 2. If element is a sub, return "subscript". if (element->local_name() == HTML::TagNames::sub) return "subscript"_utf16; // 3. Return null. return {}; } // 4. If command is "strikethrough", and element has a style attribute set, and that attribute sets // "text-decoration": if (command == CommandNames::strikethrough) { auto text_decoration_style = property_in_style_attribute(element, CSS::PropertyID::TextDecoration); if (text_decoration_style) { // 1. If element's style attribute sets "text-decoration" to a value containing "line-through", return // "line-through". if (value_contains_keyword(*text_decoration_style, CSS::Keyword::LineThrough)) return "line-through"_utf16; // 2. Return null. return {}; } } // 5. If command is "strikethrough" and element is an s or strike element, return "line-through". if (command == CommandNames::strikethrough && element->local_name().is_one_of(HTML::TagNames::s, HTML::TagNames::strike)) return "line-through"_utf16; // 6. If command is "underline", and element has a style attribute set, and that attribute sets "text-decoration": if (command == CommandNames::underline) { auto text_decoration_style = property_in_style_attribute(element, CSS::PropertyID::TextDecoration); if (text_decoration_style) { // 1. If element's style attribute sets "text-decoration" to a value containing "underline", return "underline". if (value_contains_keyword(*text_decoration_style, CSS::Keyword::Underline)) return "underline"_utf16; // 2. Return null. return {}; } } // 7. If command is "underline" and element is a u element, return "underline". if (command == CommandNames::underline && element->local_name() == HTML::TagNames::u) return "underline"_utf16; // 8. Let property be the relevant CSS property for command. auto property = find_command_definition(command)->relevant_css_property; // 9. If property is null, return null. if (!property.has_value()) return {}; // 10. If element has a style attribute set, and that attribute has the effect of setting property, return the value // that it sets property to. // FIXME: Use property_in_style_attribute once it supports shorthands. if (auto inline_style = element->inline_style()) { auto value = inline_style->get_property_value(string_from_property_id(property.value())); if (!value.is_empty()) return Utf16String::from_utf8_without_validation(value); } // 11. If element is a font element that has an attribute whose effect is to create a presentational hint for // property, return the value that the hint sets property to. (For a size of 7, this will be the non-CSS value // "xxx-large".) if (is(*element)) { auto const& font_element = static_cast(*element); Vector presentational_hint_properties; font_element.apply_presentational_hints(presentational_hint_properties); if (auto hint = presentational_hint_properties.first_matching([&](auto& it) { return it.property_id == property.value(); }); hint.has_value()) return Utf16String::from_utf8_without_validation(hint->value->to_string(CSS::SerializationMode::Normal)); } // 12. If element is in the following list, and property is equal to the CSS property name listed for it, return the // string listed for it. // * b, strong: font-weight: "bold" // * i, em: font-style: "italic" if (element->local_name().is_one_of(HTML::TagNames::b, HTML::TagNames::strong) && *property == CSS::PropertyID::FontWeight) return "bold"_utf16; if (element->local_name().is_one_of(HTML::TagNames::i, HTML::TagNames::em) && *property == CSS::PropertyID::FontStyle) return "italic"_utf16; // 13. Return null. return {}; } // https://w3c.github.io/editing/docs/execCommand/#split-the-parent void split_the_parent_of_nodes(Vector> const& node_list) { VERIFY(!node_list.is_empty()); // 1. Let original parent be the parent of the first member of node list. GC::Ref first_node = *node_list.first(); GC::Ref last_node = *node_list.last(); GC::Ref original_parent = *first_node->parent(); // 2. If original parent is not editable or its parent is null, do nothing and abort these steps. if (!original_parent->is_editable() || !original_parent->parent()) return; // 3. If the first child of original parent is in node list, remove extraneous line breaks before original parent. GC::Ref first_child = *original_parent->first_child(); auto first_child_in_nodes_list = node_list.contains_slow(first_child); if (first_child_in_nodes_list) remove_extraneous_line_breaks_before_node(original_parent); // 4. If the first child of original parent is in node list, and original parent follows a line break, set follows // line break to true. Otherwise, set follows line break to false. auto follows_line_break = first_child_in_nodes_list && follows_a_line_break(original_parent); // 5. If the last child of original parent is in node list, and original parent precedes a line break, set precedes // line break to true. Otherwise, set precedes line break to false. GC::Ref last_child = *original_parent->last_child(); bool last_child_in_nodes_list = node_list.contains_slow(last_child); auto precedes_line_break = last_child_in_nodes_list && precedes_a_line_break(original_parent); // 6. If the first child of original parent is not in node list, but its last child is: GC::Ref parent_of_original_parent = *original_parent->parent(); auto original_parent_index = original_parent->index(); auto& document = original_parent->document(); if (!first_child_in_nodes_list && last_child_in_nodes_list) { // 1. For each node in node list, in reverse order, insert node into the parent of original parent immediately // after original parent, preserving ranges. for (auto node : node_list.in_reverse()) move_node_preserving_ranges(node, parent_of_original_parent, original_parent_index + 1); // 2. If precedes line break is true, and the last member of node list does not precede a line break, call // createElement("br") on the context object and insert the result immediately after the last member of node // list. if (precedes_line_break && !precedes_a_line_break(last_node)) { auto br_element = MUST(DOM::create_element(document, HTML::TagNames::br, Namespace::HTML)); MUST(last_node->parent()->append_child(br_element)); } // 3. Remove extraneous line breaks at the end of original parent. remove_extraneous_line_breaks_at_the_end_of_node(original_parent); // 4. Abort these steps. return; } // 7. If the first child of original parent is not in node list: if (!first_child_in_nodes_list) { // 1. Let cloned parent be the result of calling cloneNode(false) on original parent. auto cloned_parent = MUST(original_parent->clone_node(nullptr, false)); // 2. If original parent has an id attribute, unset it. auto& original_parent_element = static_cast(*original_parent); if (original_parent_element.has_attribute(HTML::AttributeNames::id)) original_parent_element.remove_attribute(HTML::AttributeNames::id); // 3. Insert cloned parent into the parent of original parent immediately before original parent. original_parent->parent()->insert_before(cloned_parent, original_parent); // 4. While the previousSibling of the first member of node list is not null, append the first child of original // parent as the last child of cloned parent, preserving ranges. while (first_node->previous_sibling()) move_node_preserving_ranges(*original_parent->first_child(), cloned_parent, cloned_parent->child_count()); } // 8. For each node in node list, insert node into the parent of original parent immediately before original parent, // preserving ranges. for (auto node : node_list) move_node_preserving_ranges(node, parent_of_original_parent, original_parent_index++); // 9. If follows line break is true, and the first member of node list does not follow a line break, call // createElement("br") on the context object and insert the result immediately before the first member of node // list. if (follows_line_break && !follows_a_line_break(first_node)) { auto br_element = MUST(DOM::create_element(document, HTML::TagNames::br, Namespace::HTML)); first_node->parent()->insert_before(br_element, first_node); } // 10. If the last member of node list is an inline node other than a br, and the first child of original parent is // a br, and original parent is not an inline node, remove the first child of original parent from original // parent. if (is_inline_node(last_node) && !is(*last_node) && is(*first_child) && !is_inline_node(original_parent)) { first_child->remove(); } // 11. If original parent has no children: if (original_parent->child_count() == 0) { // 1. Remove original parent from its parent. original_parent->remove(); // 2. If precedes line break is true, and the last member of node list does not precede a line break, call // createElement("br") on the context object and insert the result immediately after the last member of node // list. if (precedes_line_break && !precedes_a_line_break(last_node)) { auto br_element = MUST(DOM::create_element(document, HTML::TagNames::br, Namespace::HTML)); last_node->parent()->insert_before(br_element, last_node->next_sibling()); } } // 12. Otherwise, remove extraneous line breaks before original parent. else { remove_extraneous_line_breaks_before_node(original_parent); } // 13. If node list's last member's nextSibling is null, but its parent is not null, remove extraneous line breaks // at the end of node list's last member's parent. if (!last_node->next_sibling() && last_node->parent()) remove_extraneous_line_breaks_at_the_end_of_node(*last_node->parent()); } enum class ToggleListMode : u8 { Enable, Disable, }; // https://w3c.github.io/editing/docs/execCommand/#toggle-lists void toggle_lists(DOM::Document& document, FlyString const& tag_name) { VERIFY(first_is_one_of(tag_name, HTML::TagNames::ol, HTML::TagNames::ul)); // 1. Let mode be "disable" if the selection's list state is tag name, and "enable" otherwise. auto mode = ToggleListMode::Enable; auto list_state = selections_list_state(document); if ((list_state == SelectionsListState::Ol && tag_name == HTML::TagNames::ol) || (list_state == SelectionsListState::Ul && tag_name == HTML::TagNames::ul)) mode = ToggleListMode::Disable; // 2. Let other tag name be "ol" if tag name is "ul", and "ul" if tag name is "ol". auto other_tag_name = tag_name == HTML::TagNames::ul ? HTML::TagNames::ol : HTML::TagNames::ul; // 3. Let items be a list of all lis that are inclusive ancestors of the active range's start and/or end node. Vector> items; auto add_li_ancestors = [&items](GC::Ref node) { node->for_each_inclusive_ancestor([&items](GC::Ref ancestor) { if (is(*ancestor) && !items.contains_slow(ancestor)) items.append(ancestor); return IterationDecision::Continue; }); }; auto range = active_range(document); add_li_ancestors(range->start_container()); add_li_ancestors(range->end_container()); // 4. For each item in items, normalize sublists of item. for (auto item : items) normalize_sublists_in_node(item); // 5. Block-extend the active range, and let new range be the result. auto new_range = block_extend_a_range(*active_range(document)); // 6. If mode is "enable", then let lists to convert consist of every editable HTML element with local name other // tag name that is contained in new range, and for every list in lists to convert: if (mode == ToggleListMode::Enable) { Vector> lists_to_convert; new_range->for_each_contained([&](GC::Ref node) { if (node->is_editable() && is(*node) && static_cast(*node).local_name() == other_tag_name) lists_to_convert.append(node); return IterationDecision::Continue; }); for (auto list : lists_to_convert) { // 1. If list's previousSibling or nextSibling is an editable HTML element with local name tag name: if ((is(list->previous_sibling()) && list->previous_sibling()->is_editable() && static_cast(*list->previous_sibling()).local_name() == tag_name) || (is(list->next_sibling()) && list->next_sibling()->is_editable() && static_cast(*list->next_sibling()).local_name() == tag_name)) { // 1. Let children be list's children. Vector> children; list->for_each_child([&children](GC::Ref child) { children.append(child); return IterationDecision::Continue; }); // 2. Record the values of children, and let values be the result. auto values = record_the_values_of_nodes(document.heap(), children); // 3. Split the parent of children. split_the_parent_of_nodes(children); // 4. Wrap children, with sibling criteria returning true for an HTML element with local name tag name and // false otherwise. wrap( children, [&tag_name](GC::Ref sibling) { return is(*sibling) && static_cast(*sibling).local_name() == tag_name; }, {}); // 5. Restore the values from values. restore_the_values_of_nodes(values); } // 2. Otherwise, set the tag name of list to tag name. else { set_the_tag_name(static_cast(*list), tag_name); } } } // 7. Let node list be a list of nodes, initially empty. Vector> node_list; // 8. For each node node contained in new range, if node is editable; the last member of node list (if any) is not // an ancestor of node; node is not an indentation element; and either node is an ol or ul, or its parent is an // ol or ul, or it is an allowed child of "li"; then append node to node list. new_range->for_each_contained([&node_list](GC::Ref node) { if (node->is_editable() && (node_list.is_empty() || !node_list.last()->is_ancestor_of(node)) && !is_indentation_element(node) && ((is(*node) || is(*node)) || (is(node->parent()) || is(node->parent())) || is_allowed_child_of_node(node, HTML::TagNames::li))) node_list.append(node); return IterationDecision::Continue; }); // 9. If mode is "enable", remove from node list any ol or ul whose parent is not also an ol or ul. if (mode == ToggleListMode::Enable) { node_list.remove_all_matching([](GC::Ref node) { return (is(*node) && !is(node->parent())) || (is(*node) && !is(node->parent())); }); } // 10. If mode is "disable", then while node list is not empty: if (mode == ToggleListMode::Disable) { while (!node_list.is_empty()) { // 1. Let sublist be an empty list of nodes. Vector> sublist; // 2. Remove the first member from node list and append it to sublist. sublist.append(node_list.take_first()); // 3. If the first member of sublist is an HTML element with local name tag name, outdent it and continue this // loop from the beginning. if (is(*sublist.first()) && static_cast(*sublist.first()).local_name() == tag_name) { outdent(sublist.first()); continue; } // 4. While node list is not empty, and the first member of node list is the nextSibling of the last member of // sublist and is not an HTML element with local name tag name, remove the first member from node list and // append it to sublist. while (!node_list.is_empty() && node_list.first().ptr() == sublist.last()->next_sibling() && !(is(*node_list.first()) && static_cast(*node_list.first()).local_name() == tag_name)) sublist.append(node_list.take_first()); // 5. Record the values of sublist, and let values be the result. auto values = record_the_values_of_nodes(document.heap(), sublist); // 6. Split the parent of sublist. split_the_parent_of_nodes(sublist); // 7. Fix disallowed ancestors of each member of sublist. for (auto member : sublist) fix_disallowed_ancestors_of_node(member); // 8. Restore the values from values. restore_the_values_of_nodes(values); } } // 11. Otherwise, while node list is not empty: else { while (!node_list.is_empty()) { // 1. Let sublist be an empty list of nodes. Vector> sublist; // 2. While either sublist is empty, or node list is not empty and its first member is the nextSibling of // sublist's last member: // AD-HOC: This condition needs to be a bit different from what the spec describes, because node_list and // sublist can both be empty at the same time: https://github.com/w3c/editing/issues/521 while (!node_list.is_empty() && (sublist.is_empty() || node_list.first().ptr() == sublist.last()->next_sibling())) { // 1. If node list's first member is a p or div, set the tag name of node list's first member to "li", // and append the result to sublist. Remove the first member from node list. if (is(*node_list.first()) || is(*node_list.first())) { sublist.append(set_the_tag_name(static_cast(*node_list.first()), HTML::TagNames::li)); node_list.take_first(); } // 2. Otherwise, if the first member of node list is an li or ol or ul, remove it from node list and // append it to sublist. else if (is(*node_list.first()) && (is(*node_list.first()) || is(*node_list.first()) || is(*node_list.first()))) { sublist.append(node_list.take_first()); } // 3. Otherwise: else { // 1. Let nodes to wrap be a list of nodes, initially empty. Vector> nodes_to_wrap; // 2. While nodes to wrap is empty, or node list is not empty and its first member is the // nextSibling of nodes to wrap's last member and the first member of node list is an inline node // and the last member of nodes to wrap is an inline node other than a br, remove the first // member from node list and append it to nodes to wrap. while (nodes_to_wrap.is_empty() || (!node_list.is_empty() && node_list.first().ptr() == nodes_to_wrap.last()->next_sibling() && is_inline_node(node_list.first()) && is_inline_node(nodes_to_wrap.last()) && !is(*nodes_to_wrap.last()))) nodes_to_wrap.append(node_list.take_first()); // 3. Wrap nodes to wrap, with new parent instructions returning the result of calling // createElement("li") on the context object. Append the result to sublist. auto result = wrap( nodes_to_wrap, {}, [&] { return MUST(DOM::create_element(document, HTML::TagNames::li, Namespace::HTML)); }); if (result) sublist.append(*result); } } // 3. If sublist's first member's parent is an HTML element with local name tag name, or if every member of // sublist is an ol or ul, continue this loop from the beginning. if (!sublist.is_empty() && is(sublist.first()->parent()) && static_cast(*sublist.first()->parent()).local_name() == tag_name) continue; bool all_are_ol_or_ul = true; for (auto member : sublist) { if (!is(*member) && !is(*member)) { all_are_ol_or_ul = false; break; } } if (all_are_ol_or_ul) continue; // 4. If sublist's first member's parent is an HTML element with local name other tag name: if (!sublist.is_empty() && is(sublist.first()->parent()) && static_cast(*sublist.first()->parent()).local_name() == other_tag_name) { // 1. Record the values of sublist, and let values be the result. auto values = record_the_values_of_nodes(document.heap(), sublist); // 2. Split the parent of sublist. split_the_parent_of_nodes(sublist); // 3. Wrap sublist, with sibling criteria returning true for an HTML element with local name tag name // and false otherwise, and new parent instructions returning the result of calling // createElement(tag name) on the context object. wrap( sublist, [&](GC::Ref sibling) { return is(*sibling) && static_cast(*sibling).local_name() == tag_name; }, [&] { return MUST(DOM::create_element(document, tag_name, Namespace::HTML)); }); // 4. Restore the values from values. restore_the_values_of_nodes(values); // 5. Continue this loop from the beginning. continue; } // 5. Wrap sublist, with sibling criteria returning true for an HTML element with local name tag name and // false otherwise, and new parent instructions being the following: auto result = wrap( sublist, [&](GC::Ref sibling) { return is(*sibling) && static_cast(*sibling).local_name() == tag_name; }, [&] -> GC::Ptr { // 1. If sublist's first member's parent is not an editable simple indentation element, or sublist's // first member's parent's previousSibling is not an editable HTML element with local name tag name, // call createElement(tag name) on the context object and return the result. auto* first_parent = sublist.first()->parent(); if (!first_parent->is_editable() || !is_simple_indentation_element(*first_parent) || !(is(first_parent->previous_sibling()) && static_cast(*first_parent->previous_sibling()).local_name() == tag_name)) return MUST(DOM::create_element(document, tag_name, Namespace::HTML)); // 2. Let list be sublist's first member's parent's previousSibling. GC::Ref list = *sublist.first()->parent()->previous_sibling(); // 3. Normalize sublists of list's lastChild. normalize_sublists_in_node(*list->last_child()); // 4. If list's lastChild is not an editable HTML element with local name tag name, call // createElement(tag name) on the context object, and append the result as the last child of list. if (!list->last_child()->is_editable() || !is(list->last_child()) || static_cast(*list->last_child()).local_name() != tag_name) MUST(list->append_child(MUST(DOM::create_element(document, tag_name, Namespace::HTML)))); // 5. Return the last child of list. return list->last_child(); }); // 6. Fix disallowed ancestors of the previous step's result. if (result) fix_disallowed_ancestors_of_node(*result); } } } // https://w3c.github.io/editing/docs/execCommand/#equivalent-values bool values_are_equivalent(FlyString const& command, Optional a, Optional b) { // Two quantities are equivalent values for a command if either both are null, if (!a.has_value() && !b.has_value()) return true; // NOTE: Both need to be strings for all remaining conditions. if (!a.has_value() || !b.has_value()) return false; // or both are strings and the command defines equivalent values and they match the definition. if (command.is_one_of(CommandNames::backColor, CommandNames::foreColor, CommandNames::hiliteColor)) { // Either both strings are valid CSS colors and have the same red, green, blue, and alpha components, or neither // string is a valid CSS color. auto a_color = Color::from_utf16_string(a.value()); auto b_color = Color::from_utf16_string(b.value()); if (a_color.has_value()) return a_color == b_color; return !a_color.has_value() && !b_color.has_value(); } if (command == CommandNames::bold) { // Either the two strings are equal, or one is "bold" and the other is "700", or one is "normal" and the other // is "400". if (a.value() == b.value()) return true; auto either_is_bold = first_is_one_of("bold"sv, a.value(), b.value()); auto either_is_700 = first_is_one_of("700"sv, a.value(), b.value()); auto either_is_normal = first_is_one_of("normal"sv, a.value(), b.value()); auto either_is_400 = first_is_one_of("400"sv, a.value(), b.value()); return (either_is_bold && either_is_700) || (either_is_normal && either_is_400); } // or both are strings and they're equal and the command does not define any equivalent values, return a.value() == b.value(); } // https://w3c.github.io/editing/docs/execCommand/#loosely-equivalent-values bool values_are_loosely_equivalent(FlyString const& command, Optional a, Optional b) { // Two quantities are loosely equivalent values for a command if either they are equivalent values for the command, if (values_are_equivalent(command, a, b)) return true; // or if the command is the fontSize command; one of the quantities is one of "x-small", "small", "medium", "large", // "x-large", "xx-large", or "xxx-large"; and the other quantity is the resolved value of "font-size" on a font // element whose size attribute has the corresponding value set ("1" through "7" respectively). if (command == CommandNames::fontSize && a.has_value() && b.has_value()) { static constexpr Array named_quantities { "x-small"sv, "small"sv, "medium"sv, "large"sv, "x-large"sv, "xx-large"sv, "xxx-large"sv }; static constexpr Array size_quantities { "1"sv, "2"sv, "3"sv, "4"sv, "5"sv, "6"sv, "7"sv }; static_assert(named_quantities.size() == size_quantities.size()); auto a_index = named_quantities.first_index_of(a.value()) .value_or_lazy_evaluated_optional([&] { return size_quantities.first_index_of(a.value()); }); auto b_index = named_quantities.first_index_of(b.value()) .value_or_lazy_evaluated_optional([&] { return size_quantities.first_index_of(b.value()); }); return a_index.has_value() && a_index == b_index; } return false; } // https://w3c.github.io/editing/docs/execCommand/#wrap GC::Ptr wrap( Vector> node_list, Function)> sibling_criteria, Function()> new_parent_instructions) { VERIFY(!node_list.is_empty()); // If not provided, sibling criteria returns false and new parent instructions returns null. if (!sibling_criteria) sibling_criteria = [](auto) { return false; }; if (!new_parent_instructions) new_parent_instructions = [] { return nullptr; }; // 1. If every member of node list is invisible, and none is a br, return null and abort these steps. auto any_node_visible_or_br = false; for (auto& node : node_list) { if (is_visible_node(node) || is(*node)) { any_node_visible_or_br = true; break; } } if (!any_node_visible_or_br) return {}; // 2. If node list's first member's parent is null, return null and abort these steps. if (!node_list.first()->parent()) return {}; // 3. If node list's last member is an inline node that's not a br, and node list's last member's nextSibling is a // br, append that br to node list. auto last_member = node_list.last(); if (is_inline_node(last_member) && !is(*last_member) && is(last_member->next_sibling())) node_list.append(*last_member->next_sibling()); // 4. While node list's first member's previousSibling is invisible, prepend it to node list. while (node_list.first()->previous_sibling() && is_invisible_node(*node_list.first()->previous_sibling())) node_list.prepend(*node_list.first()->previous_sibling()); // 5. While node list's last member's nextSibling is invisible, append it to node list. while (node_list.last()->next_sibling() && is_invisible_node(*node_list.last()->next_sibling())) node_list.append(*node_list.last()->next_sibling()); auto new_parent = [&]() -> GC::Ptr { // 6. If the previousSibling of the first member of node list is editable and running sibling criteria on it returns // true, let new parent be the previousSibling of the first member of node list. GC::Ptr previous_sibling = node_list.first()->previous_sibling(); if (previous_sibling && previous_sibling->is_editable() && sibling_criteria(*previous_sibling)) return previous_sibling; // 7. Otherwise, if the nextSibling of the last member of node list is editable and running sibling criteria on it // returns true, let new parent be the nextSibling of the last member of node list. GC::Ptr next_sibling = node_list.last()->next_sibling(); if (next_sibling && next_sibling->is_editable() && sibling_criteria(*next_sibling)) return next_sibling; // 8. Otherwise, run new parent instructions, and let new parent be the result. return new_parent_instructions(); }(); // 9. If new parent is null, abort these steps and return null. if (!new_parent) return {}; // 10. If new parent's parent is null: if (!new_parent->parent()) { // 1. Insert new parent into the parent of the first member of node list immediately before the first member of // node list. auto first_member = node_list.first(); first_member->parent()->insert_before(*new_parent, first_member); // 2. If any range has a boundary point with node equal to the parent of new parent and offset equal to the // index of new parent, add one to that boundary point's offset. auto new_parent_index = new_parent->index(); auto active_range = new_parent->document().get_selection()->range(); if (active_range && active_range->start_container() == new_parent && active_range->start_offset() == new_parent_index) MUST(active_range->set_start(active_range->start_container(), new_parent_index + 1)); if (active_range && active_range->end_container() == new_parent && active_range->end_offset() == new_parent_index) MUST(active_range->set_end(active_range->end_container(), new_parent_index + 1)); } // 11. Let original parent be the parent of the first member of node list. auto const original_parent = GC::Ptr { node_list.first()->parent() }; // 12. If new parent is before the first member of node list in tree order: if (new_parent->is_before(node_list.first())) { // 1. If new parent is not an inline node, but the last visible child of new parent and the first visible member // of node list are both inline nodes, and the last child of new parent is not a br, call createElement("br") // on the ownerDocument of new parent and append the result as the last child of new parent. if (!is_inline_node(*new_parent)) { auto last_visible_child = [&] -> GC::Ptr { GC::Ptr child = new_parent->last_child(); while (child) { if (is_visible_node(*child)) return *child; child = child->previous_sibling(); } return {}; }(); auto first_visible_member = [&] -> GC::Ptr { for (auto& member : node_list) { if (is_visible_node(member)) return member; } return {}; }(); if (last_visible_child && is_inline_node(*last_visible_child) && first_visible_member && is_inline_node(*first_visible_member) && !is(new_parent->last_child())) { auto br_element = MUST(DOM::create_element(*new_parent->owner_document(), HTML::TagNames::br, Namespace::HTML)); MUST(new_parent->append_child(br_element)); } } // 2. For each node in node list, append node as the last child of new parent, preserving ranges. auto new_position = new_parent->child_count(); for (auto& node : node_list) move_node_preserving_ranges(node, *new_parent, new_position++); } // 13. Otherwise: else { // 1. If new parent is not an inline node, but the first visible child of new parent and the last visible member // of node list are both inline nodes, and the last member of node list is not a br, call createElement("br") // on the ownerDocument of new parent and insert the result as the first child of new parent. if (!is_inline_node(*new_parent)) { auto first_visible_child = [&] -> GC::Ref { GC::Ptr child = new_parent->first_child(); while (child) { if (is_visible_node(*child)) return *child; child = child->next_sibling(); } VERIFY_NOT_REACHED(); }(); auto last_visible_member = [&] -> GC::Ref { for (auto& member : node_list.in_reverse()) { if (is_visible_node(member)) return member; } VERIFY_NOT_REACHED(); }(); if (is_inline_node(first_visible_child) && is_inline_node(last_visible_member) && !is(*node_list.last())) { auto br_element = MUST(DOM::create_element(*new_parent->owner_document(), HTML::TagNames::br, Namespace::HTML)); new_parent->insert_before(br_element, new_parent->first_child()); } } // 2. For each node in node list, in reverse order, insert node as the first child of new parent, preserving // ranges. for (auto& node : node_list.in_reverse()) move_node_preserving_ranges(node, *new_parent, 0); } // 14. If original parent is editable and has no children, remove it from its parent. if (original_parent->is_editable() && !original_parent->has_children()) original_parent->remove(); // 15. If new parent's nextSibling is editable and running sibling criteria on it returns true: GC::Ptr next_sibling = new_parent->next_sibling(); if (next_sibling && next_sibling->is_editable() && sibling_criteria(*next_sibling)) { // 1. If new parent is not an inline node, but new parent's last child and new parent's nextSibling's first // child are both inline nodes, and new parent's last child is not a br, call createElement("br") on the // ownerDocument of new parent and append the result as the last child of new parent. if (!is_inline_node(*new_parent) && is_inline_node(*new_parent->last_child()) && is_inline_node(*next_sibling->first_child()) && !is(new_parent->last_child())) { auto br_element = MUST(DOM::create_element(*new_parent->owner_document(), HTML::TagNames::br, Namespace::HTML)); MUST(new_parent->append_child(br_element)); } // 2. While new parent's nextSibling has children, append its first child as the last child of new parent, // preserving ranges. auto new_position = new_parent->child_count(); while (next_sibling->has_children()) move_node_preserving_ranges(*next_sibling->first_child(), *new_parent, new_position++); // 3. Remove new parent's nextSibling from its parent. next_sibling->remove(); } // 16. Remove extraneous line breaks from new parent. remove_extraneous_line_breaks_from_a_node(*new_parent); // 17. Return new parent. return new_parent; } GC::Ptr first_formattable_node_effectively_contained(GC::Ptr range) { GC::Ptr node; for_each_node_effectively_contained_in_range(range, [&](GC::Ref descendant) { if (is_formattable_node(descendant)) { node = descendant; return TraversalDecision::Break; } return TraversalDecision::Continue; }); return node; } CSSPixels font_size_to_pixel_size(Utf16View const& font_size) { // If the font size ends in 'px', interpret the preceding as a number and return it. if (font_size.ends_with("px"sv)) { auto optional_number = font_size.substring_view(0, font_size.length_in_code_units() - 2).to_number(); if (optional_number.has_value()) return CSSPixels::nearest_value_for(optional_number.value()); } // Try to map the font size directly to a keyword (e.g. medium or x-large) auto keyword = CSS::keyword_from_string(font_size.to_utf8_but_should_be_ported_to_utf16()); // If that failed, try to interpret it as a legacy font size (e.g. 1 through 7) if (!keyword.has_value()) keyword = HTML::HTMLFontElement::parse_legacy_font_size(font_size.to_utf8_but_should_be_ported_to_utf16()); // If that also failed, give up auto pixel_size = CSS::StyleComputer::default_user_font_size(); if (!keyword.has_value()) return pixel_size; // Convert the keyword to an absolute-size auto absolute_size = CSS::keyword_to_absolute_size(keyword.value()); // If that failed - give up if (!absolute_size.has_value()) return pixel_size; // Return scaled pixel size return CSS::StyleComputer::absolute_size_mapping(absolute_size.value(), pixel_size); } void for_each_node_effectively_contained_in_range(GC::Ptr range, Function)> callback) { if (!range) return; // A node can still be "effectively contained" in range even if it's not actually contained within the range; so we // need to do an inclusive subtree traversal since the common ancestor could be matched as well. range->common_ancestor_container()->for_each_in_inclusive_subtree([&](GC::Ref descendant) { if (!is_effectively_contained_in_range(descendant, *range)) { // NOTE: We cannot skip children here since if a descendant is not effectively contained within a range, its // children might still be. return TraversalDecision::Continue; } return callback(descendant); }); } bool has_visible_children(GC::Ref node) { bool has_visible_child = false; node->for_each_child([&has_visible_child](GC::Ref child) { if (is_visible_node(child)) { has_visible_child = true; return IterationDecision::Break; } return IterationDecision::Continue; }); return has_visible_child; } bool is_heading(FlyString const& local_name) { return local_name.is_one_of( HTML::TagNames::h1, HTML::TagNames::h2, HTML::TagNames::h3, HTML::TagNames::h4, HTML::TagNames::h5, HTML::TagNames::h6); } Utf16String justify_alignment_to_string(JustifyAlignment alignment) { switch (alignment) { case JustifyAlignment::Center: return "center"_utf16; case JustifyAlignment::Justify: return "justify"_utf16; case JustifyAlignment::Left: return "left"_utf16; case JustifyAlignment::Right: return "right"_utf16; } VERIFY_NOT_REACHED(); } Array named_font_sizes() { return { "x-small"sv, "small"sv, "medium"sv, "large"sv, "x-large"sv, "xx-large"sv, "xxx-large"sv }; } RefPtr property_in_style_attribute(GC::Ref element, CSS::PropertyID property_id) { auto inline_style = element->inline_style(); if (!inline_style) return {}; auto style_property = inline_style->get_property(property_id); if (!style_property.has_value()) return {}; return style_property.value().value; } Optional resolved_display(GC::Ref node) { auto resolved_property = resolved_value(node, CSS::PropertyID::Display); if (!resolved_property || !resolved_property->is_display()) return {}; return resolved_property->as_display().display(); } Optional resolved_keyword(GC::Ref node, CSS::PropertyID property_id) { auto resolved_property = resolved_value(node, property_id); if (!resolved_property || !resolved_property->is_keyword()) return {}; return resolved_property->as_keyword().keyword(); } RefPtr resolved_value(GC::Ref node, CSS::PropertyID property_id) { // Find the nearest inclusive ancestor of node that is an Element. This allows for passing in a DOM::Text node. GC::Ptr element = node; while (element && !is(*element)) element = element->parent(); if (!element) return {}; // Retrieve resolved style value auto resolved_css_style_declaration = CSS::CSSStyleProperties::create_resolved_style(element->realm(), DOM::AbstractElement { static_cast(*element) }); auto optional_style_property = resolved_css_style_declaration->get_property(property_id); if (!optional_style_property.has_value()) return {}; return optional_style_property.value().value; } void take_the_action_for_command(DOM::Document& document, FlyString const& command, Utf16String const& value) { auto const& command_definition = find_command_definition(command); command_definition->action(document, value); } bool value_contains_keyword(CSS::StyleValue const& value, CSS::Keyword keyword) { if (value.is_value_list()) { for (auto& css_style_value : value.as_value_list().values()) { if (css_style_value->is_keyword() && css_style_value->as_keyword().keyword() == keyword) return true; } } return value.to_keyword() == keyword; } }