jekyll-l10n 2.0.0 → 3.0.0

data/lib/jekyll-l10n/utils/debug_logger.rb

@@ -8,14 +8,12 @@ module Jekyll
     #
     # DebugLogger provides detailed logging of translation attempts for
     # debugging normalization and matching issues. It logs when translations
-    # are found, when translations are missing, character-level differences,
-    # and similarity analysis for debugging.
+    # are found, when translations are missing, and similarity analysis for
+    # debugging.
     #
     # Key responsibilities:
     # * Log translation match details
     # * Log missing translations with similar key analysis
-    # * Log character-level differences for debugging
-    # * Provide context around matching failures
     # * Support verbose translation debugging
     #
     # @see Jekyll::L10n::HtmlTranslator for translation workflow context
@@ -69,18 +67,6 @@ module Jekyll
         log_alert_comparison(text, normalized_text, key_from_hash)
       end
 
-      def self.log_first_difference(normalized_text, key_from_hash)
-        (0...normalized_text.length).each do |i|
-          next unless normalized_text[i] != key_from_hash[i]
-
-          log_difference_at_position(normalized_text, key_from_hash, i)
-          log_context_strings(normalized_text, key_from_hash, i)
-          break
-        end
-
-        log_normalization_match
-      end
-
       def self.log_found_translation(text, translated)
         return unless translated && translated.length > Jekyll::L10n::Constants::LOG_THRESHOLD_SHORT
 
@@ -108,46 +94,13 @@ module Jekyll
         log_message("[HtmlTranslator] NORMALIZED match: #{normalized_text == key_from_hash}")
       end
 
-      def self.log_difference_at_position(text1, text2, index)
-        char1 = text1[index]
-        char2 = text2[index]
-        log_message(
-          "[HtmlTranslator] DIFF at position #{index}: " \
-          "NORMALIZED=#{char1.inspect} (#{char1.ord}) vs KEY=#{char2.inspect} (#{char2.ord})"
-        )
-      end
-
-      def self.log_context_strings(normalized_text, key_from_hash, index)
-        normalized_context = context_string(normalized_text, index)
-        key_context = context_string(key_from_hash, index)
-
-        log_message("[HtmlTranslator] Context NORMALIZED: ...#{normalized_context.inspect}...")
-        log_message("[HtmlTranslator] Context KEY:        ...#{key_context.inspect}...")
-      end
-
-      def self.log_normalization_match
-        log_message(
-          '[HtmlTranslator] ✓ Text matches after normalization - translation will be applied'
-        )
-      end
-
       def self.log_message(message)
-        Jekyll.logger.info 'Localization', message
-      end
-
-      def self.context_string(text, index)
-        start_idx = [0, index - Jekyll::L10n::Constants::BACKTRACE_CONTEXT_LENGTH].max
-        end_idx = [index + Jekyll::L10n::Constants::BACKTRACE_CONTEXT_LENGTH, text.length - 1].min
-        text[start_idx..end_idx]
+        Jekyll.logger.info Constants::LOG_PREFIX, message
       end
 
       private_class_method :log_no_translation_found,
                            :log_alert_comparison,
-                           :log_difference_at_position,
-                           :log_context_strings,
-                           :log_normalization_match,
-                           :log_message,
-                           :context_string
+                           :log_message
     end
   end
 end

data/lib/jekyll-l10n/utils/error_handler.rb

@@ -1,24 +1,25 @@
 # frozen_string_literal: true
 
+require_relative '../constants'
+
 module Jekyll
   module L10n
     # Handles errors with graceful fallback and logging.
     #
     # ErrorHandler provides error handling utilities for gracefully managing
-    # exceptions, logging them with context, and providing default fallback values.
-    # This keeps the build process running even when individual operations fail.
+    # exceptions and logging them with context. This keeps the build process
+    # running even when individual operations fail.
     #
     # Key responsibilities:
     # * Execute code with error catching
     # * Log errors with context information
-    # * Provide fallback default values on error
     # * Optional debug backtraces
     #
     # @example
-    #   result = ErrorHandler.handle_with_default('file loading', {}) do
+    #   result = ErrorHandler.handle_with_logging('file loading') do
     #     load_file('config.yml')
     #   end
-    #   # Returns loaded data or {} on error
+    #   # Returns loaded data or nil on error
     class ErrorHandler
       # Execute code with error catching and fallback logging.
       #
@@ -35,22 +36,6 @@ module Jekyll
         nil
       end
 
-      # Execute code with error catching and fallback value.
-      #
-      # Executes the provided block and catches any StandardError, logging it
-      # with context and returning the default value.
-      #
-      # @param context [String] Context describing what was being done
-      # @param default_value [Object] Default value to return on error
-      # @yield Code to execute
-      # @return [Object] Result of block or default_value on error
-      def self.handle_with_default(context, default_value)
-        yield
-      rescue StandardError => e
-        log_error(context, e)
-        default_value
-      end
-
       # Log an error with context.
       #
       # Logs error message and optionally backtrace if DEBUG environment variable is set.
@@ -59,8 +44,8 @@ module Jekyll
       # @param error [StandardError] The error that occurred
       # @return [void]
       def self.log_error(context, error)
-        Jekyll.logger.error 'Localization', "Error in #{context}: #{error.message}"
-        Jekyll.logger.debug 'Localization', error.backtrace.join("\n") if ENV['DEBUG']
+        Jekyll.logger.error Constants::LOG_PREFIX, "Error in #{context}: #{error.message}"
+        Jekyll.logger.debug Constants::LOG_PREFIX, error.backtrace.join("\n") if ENV['DEBUG']
       end
 
       # Log a recoverable warning with context.
@@ -72,7 +57,7 @@ module Jekyll
       # @param error [StandardError] The error that occurred
       # @return [void]
       def self.log_warning(context, error)
-        Jekyll.logger.warn 'Localization', "Error in #{context}: #{error.message}"
+        Jekyll.logger.warn Constants::LOG_PREFIX, "Error in #{context}: #{error.message}"
       end
     end
   end

data/lib/jekyll-l10n/utils/external_link_icon_preserver.rb

@@ -23,12 +23,10 @@ module Jekyll
       # @param translated_html [String] Translated HTML potentially missing icons
       # @return [String] Translated HTML with icons restored
       def self.preserve(original_html, translated_html)
-        # Use Nokogiri::HTML() instead of DocumentFragment.parse() to preserve the full
-        # HTML document structure including DOCTYPE, html, head, and body tags.
-        # DocumentFragment.parse() is appropriate for partial HTML only, and would strip
-        # document-level structure.
-        original_doc = Nokogiri::HTML(original_html)
-        translated_doc = Nokogiri::HTML(translated_html)
+        # Parse as documents, not fragments, to keep the doctype and the html,
+        # head and body elements.
+        original_doc = HtmlParser.parse_document(original_html)
+        translated_doc = HtmlParser.parse_document(translated_html)
 
         # Find all external link icons in original
         original_icons = original_doc.css('i.fa-external-link')
@@ -37,10 +35,7 @@ module Jekyll
         # Process each icon found in the original HTML
         restore_icons_to_translated(original_icons, translated_doc)
 
-        result = translated_doc.to_html
-
-        # Remove the auto-inserted meta tag by libxml2 during HTML serialization
-        HtmlParser.remove_meta_charset(result)
+        translated_doc.to_html
       rescue StandardError => e
         ErrorHandler.log_error('preserving external link icons', e)
         translated_html
@@ -66,58 +61,6 @@ module Jekyll
           translated_link.add_child(icon_copy)
         end
       end
-
-      # Alternative method that preserves ALL inline elements, not just icons
-      # Useful for preserving SVG icons, badges, etc.
-      #
-      # @param original_html [String] Original HTML
-      # @param translated_html [String] Translated HTML
-      # @return [String] Translated HTML with all inline elements preserved
-      def self.preserve_all_inline_elements(original_html, translated_html)
-        original_doc = Nokogiri::HTML(original_html)
-        translated_doc = Nokogiri::HTML(translated_html)
-
-        # Find all links with child elements in original
-        original_links = original_doc.css('a[href]')
-        original_links.each do |original_link|
-          preserve_link_inline_elements(original_link, translated_doc)
-        end
-
-        result = translated_doc.to_html
-        HtmlParser.remove_meta_charset(result)
-      rescue StandardError => e
-        ErrorHandler.log_error('preserving inline elements', e)
-        translated_html
-      end
-
-      def self.preserve_link_inline_elements(original_link, translated_doc)
-        href = original_link['href']
-        return unless href
-
-        # Get all non-text children (i, svg, span, etc.)
-        inline_children = original_link.children.select(&:element?)
-        return if inline_children.empty?
-
-        # Find matching link in translated version
-        translated_link = translated_doc.css("a[href=\"#{href}\"]").first
-        return unless translated_link
-
-        # Append inline elements that don't already exist
-        inline_children.each do |child|
-          add_child_if_not_exists(child, translated_link)
-        end
-      end
-
-      def self.add_child_if_not_exists(child, translated_link)
-        child_class = child['class'] || ''
-        # Check if similar element already exists
-        existing = translated_link.css("#{child.name}.#{child_class.split.first}").first
-        return if existing
-
-        # Add the element
-        child_copy = child.dup
-        translated_link.add_child(child_copy)
-      end
     end
   end
 end

data/lib/jekyll-l10n/utils/html_parser.rb

@@ -1,51 +1,44 @@
 # frozen_string_literal: true
 
+require 'nokogiri'
+
 module Jekyll
   module L10n
-    # Parses HTML content using Nokogiri.
+    # Parses HTML with Nokogiri's HTML5 parser.
     #
-    # HtmlParser provides a unified interface for parsing HTML as either full
-    # documents (preserving DOCTYPE and structure) or as fragments (partial HTML).
-    # It also provides utilities for cleaning up auto-inserted meta tags that
-    # Nokogiri/libxml2 adds during serialization.
+    # Every part of the plugin parses through here, so extraction and
+    # translation see the same tree and produce the same msgids. The HTML5
+    # parser keeps a page's doctype as written and, unlike libxml2's HTML4
+    # serializer, never adds or rewrites a Content-Type meta tag, so a parsed
+    # page is written back with `to_html` as is.
     #
     # Key responsibilities:
-    # * Parse full HTML documents with DOCTYPE preservation
-    # * Parse HTML fragments for partial content
-    # * Remove auto-inserted meta charset tags
+    # * Parse full HTML documents
+    # * Parse HTML fragments, such as a msgstr
     class HtmlParser
+      # No limit on nesting depth or attributes per element: the parser's
+      # defaults raise on large generated pages.
+      PARSE_OPTIONS = { max_tree_depth: -1, max_attributes: -1 }.freeze
+
       # Parse HTML as a full document.
       #
-      # Preserves DOCTYPE, html tag, and document structure. Use this for complete
-      # HTML documents. Auto-inserted meta tags can be removed with remove_meta_charset.
-      #
       # @param html [String] HTML content to parse
-      # @return [Nokogiri::HTML::Document] Parsed HTML document
+      # @return [Nokogiri::HTML5::Document] Parsed HTML document
       def self.parse_document(html)
-        Nokogiri::HTML(html)
+        Nokogiri::HTML5(html, **PARSE_OPTIONS)
       end
 
       # Parse HTML as a fragment.
       #
-      # Parses partial HTML without wrapping in html/body tags. Use for
-      # extracting pieces of HTML content.
-      #
-      # @param html [String] HTML fragment to parse
-      # @return [Nokogiri::HTML::DocumentFragment] Parsed HTML fragment
-      def self.parse_fragment(html)
-        Nokogiri::HTML.fragment(html)
-      end
+      # @param html [String] HTML content to parse
+      # @param context [Nokogiri::XML::Element, nil] (keyword) Element the
+      #   fragment will be inserted into, which decides how it parses (inside
+      #   a <table> or an <svg>, for example); nil parses it on its own
+      # @return [Nokogiri::HTML5::DocumentFragment] Parsed fragment
+      def self.parse_fragment(html, context: nil)
+        return Nokogiri::HTML5.fragment(html, **PARSE_OPTIONS) unless context
 
-      # Remove auto-inserted meta charset tag from serialized HTML.
-      #
-      # Nokogiri/libxml2 automatically inserts a meta charset tag during
-      # serialization. This removes that tag which was not in the original HTML.
-      #
-      # @param html_string [String] Serialized HTML
-      # @return [String] HTML with meta charset tag removed
-      def self.remove_meta_charset(html_string)
-        pattern = %r{<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">\n?}
-        html_string.gsub(pattern, '')
+        Nokogiri::HTML5::DocumentFragment.new(context.document, html, context, **PARSE_OPTIONS)
       end
     end
   end

data/lib/jekyll-l10n/utils/html_text_utils.rb

@@ -9,16 +9,15 @@ module Jekyll
     # Utilities for extracting and manipulating HTML text content.
     #
     # HtmlTextUtils provides helpers for extracting text from HTML elements while
-    # preserving inline formatting, removing block-level elements, decoding HTML
-    # entities, and cleaning up icon tags. These utilities support the extraction
-    # and translation pipelines.
+    # preserving inline formatting, removing block-level elements, and cleaning
+    # up icon tags. These utilities support the extraction and translation
+    # pipelines.
     #
     # Key responsibilities:
     # * Extract text with inline HTML tags preserved
     # * Remove block-level elements from cloned nodes
     # * Remove empty icon tags
-    # * Decode HTML entities to plain text
-    # * Validate extracted text content
+    # * Tell content elements apart from other nodes
     module HtmlTextUtils
       # Extended content elements for text extraction (includes inline elements)
       CONTENT_ELEMENTS = %w[
@@ -31,24 +30,6 @@ module Jekyll
       CONTAINER_ELEMENTS = HtmlElements::CONTAINER_ELEMENTS
       ALL_BLOCK_ELEMENTS = (CONTENT_ELEMENTS + CONTAINER_ELEMENTS).freeze
 
-      # Decode HTML entities to plain text.
-      #
-      # Converts HTML entities (&, <, etc.) to their plain text equivalents.
-      # Uses CGI.unescape_html if available, falls back to manual replacement.
-      #
-      # @param text [String] Text with HTML entities
-      # @return [String] Text with entities decoded
-      def self.decode_html_entities(text)
-        require 'cgi'
-        CGI.unescape_html(text)
-      rescue StandardError
-        text.gsub('&', '&')
-            .gsub('&lt;', '<')
-            .gsub('&gt;', '>')
-            .gsub('&quot;', '"')
-            .gsub('&#39;', "'")
-      end
-
       # Remove preformatted code blocks from a node.
       #
       # Removes all <pre> elements entirely. With highlighter: none in Jekyll config,
@@ -73,22 +54,11 @@ module Jekyll
       # @param node [Nokogiri::XML::Node] Node to process (modified in place)
       # @return [void]
       def self.remove_block_elements_from_node(node)
-        HtmlElements::BLOCK_ELEMENTS.each do |tag|
-          node.xpath(".//#{tag}").each do |elem|
-            elem.replace(elem.children)
-          end
-        end
+        node.css(BLOCK_SELECTOR).each { |elem| elem.replace(elem.children) }
       end
 
-      # Remove block-level elements from a node.
-      #
-      # Alias for remove_block_elements_from_node for convenience.
-      #
-      # @param node [Nokogiri::XML::Node] Node to process
-      # @return [void]
-      def self.remove_block_elements(node)
-        remove_block_elements_from_node(node)
-      end
+      BLOCK_SELECTOR = HtmlElements::BLOCK_ELEMENTS.join(',').freeze
+      private_constant :BLOCK_SELECTOR
 
       # Remove empty icon tags from a node.
       #
@@ -109,78 +79,177 @@ module Jekyll
       # table rows, etc.) and must never be attempted.
       LAYOUT_ONLY_ELEMENTS = (HtmlElements::BLOCK_ELEMENTS - ALL_BLOCK_ELEMENTS - %w[pre]).freeze
 
-      # Inline elements whose content is translatable — replaced with <g id="N">.
-      PLACEHOLDERED_INLINE_TAGS = %w[a span em strong b u abbr mark label].freeze
+      # Inline elements whose content is translatable — replaced with <g id="N">,
+      # nested ones included, so their attributes never reach a msgid.
+      PLACEHOLDERED_INLINE_TAGS = %w[
+        a span em strong b u i abbr mark label
+        sup sub small s del ins q cite dfn time bdi bdo
+      ].freeze
+
+      # Inline elements without translatable content — replaced with <x id="N"></x>.
+      # The closing tag is explicit because HTML parsers ignore "/>" on unknown tags.
+      EMPTY_INLINE_TAGS = %w[img br wbr input svg].freeze
 
-      # Inline elements with literal content — tag kept, non-translatable attrs stripped.
+      # Inline elements with literal content — tag and content kept, attributes
+      # stripped.
       LITERAL_INLINE_TAGS = %w[code var kbd samp].freeze
 
-      # Attributes stripped from literal-content elements before extraction.
-      STRIP_FROM_LITERAL_TAGS = %w[class style id].freeze
+      # The markup removed from an element's text, for putting it back.
+      #
+      # text: the msgid, with <g id="N"> and <x id="N"></x> placeholders
+      # placeholders: id => [tag, { attribute => value }] of the element each
+      #   placeholder stands for
+      # literals: [tag, { attribute => value }] of each literal element, in order
+      InlineMarkup = Struct.new(:text, :placeholders, :literals)
 
       # Extract text with inline tags preserved.
       #
       # Extracts text from an element, removes block elements and empty icons,
-      # replaces translatable inline elements with <g id="N"> placeholders, and
-      # strips non-translatable attributes from literal elements (<code> etc.).
-      # HTML entities (e.g. &lt;, &gt;) are preserved verbatim.
+      # replaces inline elements with placeholders, and strips attributes from
+      # literal elements (<code> etc.). HTML entities (e.g. &lt;, &gt;) are
+      # preserved verbatim.
       #
       # @param node [Nokogiri::XML::Node] Element to extract from
-      # @return [String] Extracted and normalized text
+      # @return [String, nil] Extracted and normalized text
       def self.extract_with_inline_tags(node)
+        inline_markup(node).text
+      end
+
+      # Extract text like {.extract_with_inline_tags}, and record the markup each
+      # placeholder and literal element stands for.
+      #
+      # Extraction and translation both number placeholders here, so a msgstr's
+      # ids always refer to the same elements of the page.
+      #
+      # @param node [Nokogiri::XML::Node] Element to extract from
+      # @return [InlineMarkup]
+      def self.inline_markup(node)
         clone = node.dup
         remove_code_blocks(clone)
         remove_block_elements_from_node(clone)
         remove_empty_icon_tags(clone)
-        replace_inline_elements_with_g_placeholders(clone)
+        placeholders = replace_inline_elements_with_placeholders(clone)
+        literals = strip_attributes_from_literal_elements(clone)
+        replace_non_breaking_spaces(clone)
 
-        text = TextNormalizer.normalize(clone.inner_html)
-        text&.then { |t| TextNormalizer.normalize(t).strip }
+        InlineMarkup.new(TextNormalizer.normalize(clone.inner_html)&.strip, placeholders, literals)
       end
 
-      # Replace top-level translatable inline elements with <g id="N"> placeholders.
+      # Replace inline elements with numbered placeholders.
       #
-      # Only top-level inline elements are replaced — elements nested inside another
-      # inline element are preserved as content of the outer <g>. Literal-content
-      # elements (<code>, <var>, etc.) are not placeholdered; their non-translatable
-      # attributes are stripped instead.
+      # Elements are numbered in document order, depth first; an element nested
+      # in another gets its own placeholder inside the outer one. Elements with
+      # no text and no empty inline element inside are dropped. Elements inside a
+      # literal element are part of its literal content and are left alone.
       #
       # @param node [Nokogiri::XML::Node] Node to process (modified in place)
-      # @return [void]
-      def self.replace_inline_elements_with_g_placeholders(node)
-        g_index = 0
-        top_level_placeholdered_inline_elements(node).each do |el|
-          if el.text.strip.empty?
-            el.remove
-          else
-            g_index += 1
-            g = node.document.create_element('g')
-            g['id'] = g_index.to_s
-            el.children.each { |child| g.add_child(child.dup) }
-            el.replace(g)
-          end
+      # @return [Hash{String => Array}] id => [tag, attributes] of each replaced element
+      def self.replace_inline_elements_with_placeholders(node)
+        placeholders = {}
+        placeholder_candidates(node).each do |el|
+          next el.remove if droppable?(el)
+
+          id = (placeholders.size + 1).to_s
+          placeholders[id] = [el.name, attributes_of(el)]
+          el.replace(placeholder_for(el, id))
         end
-        strip_attributes_from_literal_elements(node)
+        placeholders
       end
 
-      def self.top_level_placeholdered_inline_elements(node)
-        node.css(PLACEHOLDERED_INLINE_TAGS.join(',')).reject do |el|
-          el.ancestors.any? do |a|
-            PLACEHOLDERED_INLINE_TAGS.include?(a.name) || LITERAL_INLINE_TAGS.include?(a.name)
-          end
+      def self.placeholder_candidates(node)
+        node.css((PLACEHOLDERED_INLINE_TAGS + EMPTY_INLINE_TAGS).join(',')).reject do |el|
+          el.ancestors.any? { |a| LITERAL_INLINE_TAGS.include?(a.name) }
         end
       end
 
-      # Strip non-translatable attributes from literal-content inline elements.
+      def self.droppable?(element)
+        PLACEHOLDERED_INLINE_TAGS.include?(element.name) && element.text.strip.empty? &&
+          element.css(EMPTY_INLINE_TAGS.join(',')).empty?
+      end
+
+      def self.placeholder_for(element, id)
+        tag = EMPTY_INLINE_TAGS.include?(element.name) ? 'x' : 'g'
+        placeholder = element.document.create_element(tag)
+        placeholder['id'] = id
+        # Move, not copy: nested elements still waiting in the candidate list
+        # must stay the nodes that list holds.
+        placeholder.children = element.children unless tag == 'x'
+        placeholder
+      end
+
+      def self.attributes_of(element)
+        element.attribute_nodes.to_h { |attr| [attr.name, attr.value] }
+      end
+
+      # Strip all attributes from literal-content inline elements.
       #
       # @param node [Nokogiri::XML::Node] Node to process (modified in place)
-      # @return [void]
+      # @return [Array<Array>] [tag, attributes] of each literal element, in order
       def self.strip_attributes_from_literal_elements(node)
-        node.css(LITERAL_INLINE_TAGS.join(',')).each do |el|
-          STRIP_FROM_LITERAL_TAGS.each { |attr| el.remove_attribute(attr) }
+        node.css(LITERAL_INLINE_TAGS.join(',')).map do |el|
+          attrs = attributes_of(el)
+          attrs.each_key { |name| el.remove_attribute(name) }
+          [el.name, attrs]
+        end
+      end
+
+      # Turn non-breaking spaces into plain ones, in text and in attribute
+      # values. The HTML5 serializer writes U+00A0 as "&nbsp;", which
+      # TextNormalizer would not collapse; msgids keep a plain space instead.
+      #
+      # @param node [Nokogiri::XML::Node] Node to process (modified in place)
+      # @return [void]
+      def self.replace_non_breaking_spaces(node)
+        node.traverse do |child|
+          if child.text?
+            child.content = child.content.tr(NBSP, ' ') if child.content.include?(NBSP)
+          elsif child.element?
+            child.attribute_nodes.each { |attr| attr.value = attr.value.tr(NBSP, ' ') if attr.value.include?(NBSP) }
+          end
         end
       end
 
+      NBSP = "\u00A0"
+      private_constant :NBSP
+
+      private_class_method :placeholder_candidates, :droppable?, :placeholder_for, :attributes_of
+
+      # The msgid of an element's text, or nil when it has none: its text sits
+      # only in block children, a layout-only block child would be flattened, or
+      # the text is too short to translate.
+      #
+      # Extraction and translation both decide here, so translation looks a
+      # block up only by a msgid extraction gave it.
+      #
+      # @param node [Nokogiri::XML::Element] Element to read
+      # @return [String, nil] The msgid, or nil
+      def self.block_text(node)
+        return nil if only_block_children?(node) || layout_block_children?(node)
+
+        text = extract_with_inline_tags(node)
+        TextValidator.valid?(text) ? text : nil
+      end
+
+      # Check whether a node's text sits only in block children: it has a block
+      # child and no text or inline element of its own.
+      #
+      # @param node [Nokogiri::XML::Node] Node to inspect
+      # @return [Boolean]
+      def self.only_block_children?(node)
+        node.children.none? { |child| own_content?(child) } &&
+          node.children.any? { |child| block_element?(child) }
+      end
+
+      # A non-blank text node, or an element outside ALL_BLOCK_ELEMENTS.
+      def self.own_content?(child)
+        (child.text? && !child.content.strip.empty?) || (child.element? && !block_element?(child))
+      end
+
+      def self.block_element?(child)
+        child.element? && ALL_BLOCK_ELEMENTS.include?(child.name)
+      end
+      private_class_method :own_content?, :block_element?
+
       # Check if a node has any direct child that is a layout-only block element.
       #
       # Layout-only elements (ul, ol, dl, table, form, etc.) are in
@@ -195,20 +264,6 @@ module Jekyll
         node.children.any? { |c| c.element? && LAYOUT_ONLY_ELEMENTS.include?(c.name) }
       end
 
-      # Extract and validate text from a node.
-      #
-      # Extracts text from element if it's a content element, then validates it
-      # meets minimum length requirements.
-      #
-      # @param node [Nokogiri::XML::Node] Node to extract from
-      # @return [String, nil] Validated text, or nil if not extractable or invalid
-      def self.extract_and_validate_text(node)
-        return nil unless extractable?(node)
-
-        text = extract_with_inline_tags(node)
-        TextValidator.valid?(text) ? text : nil
-      end
-
       # Check if a node is extractable (content element).
       #
       # @param node [Nokogiri::XML::Node] Node to check