herb 0.11.0-aarch64-linux-gnu → 0.11.1-aarch64-linux-gnu

data/lib/herb/engine/slots/visitor.rb

@@ -1202,6 +1202,11 @@ module Herb
           )
         end
 
+        #: (Array[untyped], Integer) -> String
+        def attribute_spacing(children, position)
+          position.positive? && children[position - 1].is_a?(Herb::AST::WhitespaceNode) ? "" : " "
+        end
+
         private
 
         def visit_children_with_paths(children)
@@ -1212,6 +1217,7 @@ module Herb
             @states.check_state_assignment(child)
 
             @path.push(index)
+            record_slot(child, :child) if child.is_a?(Herb::AST::RubyLiteralNode)
             visit(child)
             @path.pop
           end
@@ -1521,7 +1527,7 @@ module Herb
         def convert_helper_boolean_attribute(node)
           open_tag = @current_open_tag
 
-          return nil unless @in_open_tag && open_tag.is_a?(Herb::AST::ERBOpenTagNode)
+          return nil unless @in_open_tag && (open_tag.is_a?(Herb::AST::ERBOpenTagNode) || open_tag.is_a?(Herb::AST::HTMLOpenTagNode))
           return nil if continuation?(node)
           return nil unless node.respond_to?(:subsequent) && node.subsequent.nil?
 
@@ -1540,7 +1546,7 @@ module Herb
           return nil unless name && Herb::HTML::Util.boolean_attribute?(name)
 
           condition = @states.condition_expression(node)
-          replacement = erb_output_node(%[(" #{name}" if #{condition})])
+          replacement = erb_output_node(%[("#{attribute_spacing(children, position)}#{name}" if #{condition})])
 
           children[position] = replacement
           record_slot(replacement, :attribute)
@@ -1864,23 +1870,25 @@ module Herb
           outputs.fetch(0).content&.value&.strip
         end
 
-        def insert_markers(node)
+        #: (untyped, ?Symbol) -> untyped
+        def insert_markers(node, namespace = :html)
           anchored = content_anchor_index(node)
+          namespace = Markers.namespace_within(namespace, node.tag_name&.value&.downcase.to_s) if node.is_a?(Herb::AST::HTMLElementNode)
 
-          each_child_array(node) do |array|
+          each_child_array(node, namespace) do |array|
             index = 0
 
             while index < array.size
               child = array[index]
               slot_index = @standing[child]&.survivor&.index
 
-              insert_markers(child)
-              wrap_items(child, slot_index)
-              mark_branches(child, slot_index)
+              insert_markers(child, namespace)
+              wrap_items(child, slot_index, namespace)
+              mark_branches(child, slot_index, namespace)
 
               if slot_index && slot_index != anchored
                 if @slots[slot_index].type == :keyed
-                  park_keyed(slot_index, child)
+                  park_keyed(slot_index, child, namespace)
 
                   array.insert(
                     index,
@@ -1921,27 +1929,29 @@ module Herb
           annotation.index
         end
 
-        #: (untyped, Integer?) -> void
-        def mark_branches(node, slot_index)
+        #: (untyped, Integer?, ?Symbol) -> void
+        def mark_branches(node, slot_index, namespace = :html)
           return unless slot_index
           return unless @slots[slot_index].type == :conditional
 
           branch_bodies(node).each_with_index do |body, branch_index|
-            body.unshift(text_node(@markers.branch(slot_index, branch_index)))
+            marker = @markers.branch(slot_index, branch_index)
 
-            park_branch(@markers.statics_key(slot_index, branch_index), body)
+            park_branch(@markers.statics_key(slot_index, branch_index), marker, body, namespace)
+
+            body.unshift(text_node(marker))
           end
         end
 
-        #: (String, Array[untyped]) -> void
-        def park_branch(key, body)
+        #: (String, String, Array[untyped], Symbol) -> void
+        def park_branch(key, marker, body, namespace)
           statics = @statics
           return unless statics
 
           markup = Statics.new(@standing).markup(body)
           return unless markup
 
-          statics[key] = markup
+          statics[key] = "#{marker}#{@markers.foreign(markup, namespace)}"
         end
 
         #: (Herb::AST::DocumentNode) -> void
@@ -2062,8 +2072,8 @@ module Herb
           bodies
         end
 
-        #: (Herb::AST::Node, Integer?) -> void
-        def wrap_items(node, slot_index)
+        #: (Herb::AST::Node, Integer?, ?Symbol) -> void
+        def wrap_items(node, slot_index, namespace = :html)
           return unless slot_index
 
           slot = @slots[slot_index]
@@ -2076,7 +2086,7 @@ module Herb
             next unless body.is_a?(Array) && !body.empty?
 
             key = @markers.item_statics_key(slot_index)
-            parked = park_item(key, body)
+            parked = park_item(key, body, namespace)
 
             body.unshift(
               text_node(@markers.item_open_prefix(slot_index)),
@@ -2112,19 +2122,19 @@ module Herb
           segments.size > 1 ? segments : nil
         end
 
-        #: (Integer, untyped) -> void
-        def park_keyed(slot_index, element)
+        #: (Integer, untyped, Symbol) -> void
+        def park_keyed(slot_index, element, namespace)
           statics = @statics
           return unless statics
 
           markup = Statics.new(@standing).markup([element.open_tag, *element.body, element.close_tag].compact)
           return unless markup
 
-          statics[@markers.item_statics_key(slot_index)] = "#{@markers.branch(slot_index, Markers::ITEM_STATICS)}#{markup}"
+          statics[@markers.item_statics_key(slot_index)] = "#{@markers.branch(slot_index, Markers::ITEM_STATICS)}#{@markers.foreign(markup, namespace)}"
         end
 
-        #: (untyped, untyped) -> Array[untyped]?
-        def park_item(key, body)
+        #: (untyped, untyped, Symbol) -> Array[untyped]?
+        def park_item(key, body, namespace)
           statics = @statics
           return unless statics
 
@@ -2132,13 +2142,14 @@ module Herb
           markup = Statics.new(@standing).markup(body)
           return unless markup
 
-          statics[key] = [
-            @markers.branch(slot_index, Markers::ITEM_STATICS),
+          item = [
             @markers.item_open_prefix(slot_index),
             @markers.item_open_suffix,
             markup,
             @markers.item_close(slot_index)
           ].join
+
+          statics[key] = "#{@markers.branch(slot_index, Markers::ITEM_STATICS)}#{@markers.foreign(item, namespace)}"
         end
 
         def anchor_attributes(node, content_index = nil)
@@ -2173,8 +2184,8 @@ module Herb
           name
         end
 
-        #: (Herb::AST::Node) { (Array[untyped]) -> void } -> void
-        def each_child_array(node)
+        #: (Herb::AST::Node, ?Symbol) { (Array[untyped]) -> void } -> void
+        def each_child_array(node, namespace = :html)
           BRANCH_BODY_PROPERTIES.each do |property|
             next unless node.respond_to?(property)
 
@@ -2186,7 +2197,7 @@ module Herb
             next unless node.respond_to?(property)
 
             child = node.send(property)
-            insert_markers(child) if child
+            insert_markers(child, namespace) if child
           end
         end
 

data/lib/herb/engine.rb

@@ -220,8 +220,6 @@ module Herb
         @src << "\n" << code
         @src << "\n" unless code.end_with?("\n")
       else
-        @src.chomp! if @src.end_with?("\n") && code.start_with?(" ") && !code.end_with?("\n")
-
         @src << " " unless code.match?(/\A\n+\z/)
         @src << code
 

data/lib/herb/version.rb

@@ -2,5 +2,5 @@
 # typed: true
 
 module Herb
-  VERSION = "0.11.0"
+  VERSION = "0.11.1"
 end

data/sig/herb/ast/nodes.rbs

@@ -2133,6 +2133,7 @@ module Herb
     # |  tag_opening: Herb::Token?,
     # |  content: Herb::Token?,
     # |  tag_closing: Herb::Token?,
+    # |  prism_node: String?,
     # | }
     class ERBYieldNode < Node
       include Colors
@@ -2143,14 +2144,19 @@ module Herb
 
       attr_reader tag_closing: Herb::Token?
 
-      # : (String, Location, Array[Herb::Errors::Error], Herb::Token?, Herb::Token?, Herb::Token?) -> void
-      def initialize: (String, Location, Array[Herb::Errors::Error], Herb::Token?, Herb::Token?, Herb::Token?) -> void
+      attr_reader prism_node: String?
+
+      # : (String, Location, Array[Herb::Errors::Error], Herb::Token?, Herb::Token?, Herb::Token?, String?) -> void
+      def initialize: (String, Location, Array[Herb::Errors::Error], Herb::Token?, Herb::Token?, Herb::Token?, String?) -> void
 
       # : () -> String
       def self.type: () -> String
 
-      # : (?tag_opening: Herb::Token?, ?content: Herb::Token?, ?tag_closing: Herb::Token?, ?location: Location, ?errors: Array[Herb::Errors::Error]) -> ERBYieldNode
-      def self.build: (?tag_opening: Herb::Token?, ?content: Herb::Token?, ?tag_closing: Herb::Token?, ?location: Location, ?errors: Array[Herb::Errors::Error]) -> ERBYieldNode
+      # : (?tag_opening: Herb::Token?, ?content: Herb::Token?, ?tag_closing: Herb::Token?, ?prism_node: String?, ?location: Location, ?errors: Array[Herb::Errors::Error]) -> ERBYieldNode
+      def self.build: (?tag_opening: Herb::Token?, ?content: Herb::Token?, ?tag_closing: Herb::Token?, ?prism_node: String?, ?location: Location, ?errors: Array[Herb::Errors::Error]) -> ERBYieldNode
+
+      # : () -> Prism::node?
+      def deserialized_prism_node: () -> Prism::node?
 
       # : () -> serialized_erb_yield_node
       def to_hash: () -> serialized_erb_yield_node

data/sig/herb/bootstrap.rbs

@@ -26,6 +26,8 @@ module Herb
 
     def self.find_prism_as_bundler_sibling: () -> untyped
 
+    def self.prism_source?: (untyped path) -> untyped
+
     def self.find_prism_from_gem_spec: () -> untyped
   end
 end

data/sig/herb/dev/runner.rbs

@@ -36,6 +36,9 @@ module Herb
       # : () -> bool
       def interactive?: () -> bool
 
+      # : () -> bool
+      def process_manager?: () -> bool
+
       # : (String) -> void
       def terminal: (String) -> void
 

data/sig/herb/engine/compiler.rbs

@@ -65,6 +65,8 @@ module Herb
 
       def visit_erb_comment_node: (untyped node) -> untyped
 
+      def visit_erb_strict_locals_node: (untyped node) -> untyped
+
       def visit_erb_control_node: (untyped node) ?{ (?) -> untyped } -> untyped
 
       def visit_erb_if_node: (untyped node) -> untyped
@@ -105,9 +107,9 @@ module Herb
 
       def visit_erb_block_end_node: (untyped node, ?escaped: untyped) -> untyped
 
-      def case_parts: (untyped node) -> untyped
+      def visit_erb_case_parts: (untyped node) -> untyped
 
-      def visit_erb_control_with_parts: (untyped node, *untyped parts) -> untyped
+      def visit_erb_control_with_parts: (untyped node, *untyped parts) ?{ (?) -> untyped } -> untyped
 
       private
 
@@ -188,7 +190,7 @@ module Herb
 
       def leading_space_follows_newline?: () -> untyped
 
-      def preceding_text_ends_with_newline?: () -> untyped
+      def preceding_token_value_ends_with_newline?: () -> untyped
 
       def extract_and_remove_leading_space!: () -> untyped
 
@@ -205,6 +207,15 @@ module Herb
       # : (bool) -> void
       def settle_pending_trim_newline!: (bool) -> void
 
+      # : (Array[untyped]) -> void
+      def skip_case_children: (Array[untyped]) -> void
+
+      # : (untyped) -> bool
+      def follows_trimmed_statement_tag?: (untyped) -> bool
+
+      # : () -> void
+      def drop_pending_trim_newline!: () -> void
+
       def save_pending_leading_whitespace!: (untyped whitespace) -> untyped
 
       def restore_pending_leading_whitespace!: () -> untyped

data/sig/herb/engine/slots/dynamics_compiler.rbs

@@ -132,6 +132,9 @@ module Herb
           # : (untyped) -> void
           def visit_erb_content_node: (untyped) -> void
 
+          # : (untyped) -> void
+          def visit_ruby_literal_node: (untyped) -> void
+
           # : (untyped) -> void
           def visit_erb_yield_node: (untyped) -> void
 

data/sig/herb/engine/slots/markers.rbs

@@ -14,15 +14,29 @@ module Herb
 
         COMMENT: Regexp
 
+        FOREIGN_ATTRIBUTE: String
+
+        FOREIGN_ROOTS: Hash[Symbol, String]
+
+        SVG_INTEGRATION_POINTS: Array[String]
+
+        MATH_INTEGRATION_POINTS: Array[String]
+
         # : (String) -> bool
         def self.marker?: (String) -> bool
 
         # : (String) -> String
         def self.seeds_expression: (String) -> String
 
+        # : (Symbol, String) -> Symbol
+        def self.namespace_within: (Symbol, String) -> Symbol
+
         # : (Integer, Symbol) -> String
         def slot_open: (Integer, Symbol) -> String
 
+        # : (String, Symbol) -> String
+        def foreign: (String, Symbol) -> String
+
         # : (Array[[Integer, Symbol, String?]]) -> String
         def element_anchors: (Array[[ Integer, Symbol, String? ]]) -> String
 

data/sig/herb/engine/slots/visitor.rbs

@@ -404,6 +404,9 @@ module Herb
 
         def erb_output_node: (untyped code) -> untyped
 
+        # : (Array[untyped], Integer) -> String
+        def attribute_spacing: (Array[untyped], Integer) -> String
+
         private
 
         def visit_children_with_paths: (untyped children) -> untyped
@@ -526,16 +529,17 @@ module Herb
         # : (untyped) -> String?
         def attribute_expression_for: (untyped) -> String?
 
-        def insert_markers: (untyped node) -> untyped
+        # : (untyped, ?Symbol) -> untyped
+        def insert_markers: (untyped, ?Symbol) -> untyped
 
         # : (untyped) -> Integer?
         def content_anchor_index: (untyped) -> Integer?
 
-        # : (untyped, Integer?) -> void
-        def mark_branches: (untyped, Integer?) -> void
+        # : (untyped, Integer?, ?Symbol) -> void
+        def mark_branches: (untyped, Integer?, ?Symbol) -> void
 
-        # : (String, Array[untyped]) -> void
-        def park_branch: (String, Array[untyped]) -> void
+        # : (String, String, Array[untyped], Symbol) -> void
+        def park_branch: (String, String, Array[untyped], Symbol) -> void
 
         # : (Herb::AST::DocumentNode) -> void
         def append_statics: (Herb::AST::DocumentNode) -> void
@@ -558,25 +562,25 @@ module Herb
         # : (untyped) -> Array[Array[Herb::AST::Node]]
         def branch_bodies: (untyped) -> Array[Array[Herb::AST::Node]]
 
-        # : (Herb::AST::Node, Integer?) -> void
-        def wrap_items: (Herb::AST::Node, Integer?) -> void
+        # : (Herb::AST::Node, Integer?, ?Symbol) -> void
+        def wrap_items: (Herb::AST::Node, Integer?, ?Symbol) -> void
 
         # : (untyped) -> Array[String]?
         def attribute_segments: (untyped) -> Array[String]?
 
-        # : (Integer, untyped) -> void
-        def park_keyed: (Integer, untyped) -> void
+        # : (Integer, untyped, Symbol) -> void
+        def park_keyed: (Integer, untyped, Symbol) -> void
 
-        # : (untyped, untyped) -> Array[untyped]?
-        def park_item: (untyped, untyped) -> Array[untyped]?
+        # : (untyped, untyped, Symbol) -> Array[untyped]?
+        def park_item: (untyped, untyped, Symbol) -> Array[untyped]?
 
         def anchor_attributes: (untyped node, ?untyped content_index) -> untyped
 
         # : (Slot) -> String?
         def anchor_name_for: (Slot) -> String?
 
-        # : (Herb::AST::Node) { (Array[untyped]) -> void } -> void
-        def each_child_array: (Herb::AST::Node) { (Array[untyped]) -> void } -> void
+        # : (Herb::AST::Node, ?Symbol) { (Array[untyped]) -> void } -> void
+        def each_child_array: (Herb::AST::Node, ?Symbol) { (Array[untyped]) -> void } -> void
 
         # : (Herb::AST::DocumentNode) -> void
         def wrap_region: (Herb::AST::DocumentNode) -> void

data/sig/serialized_ast_nodes.rbs

@@ -360,6 +360,7 @@ module Herb
     tag_opening: Herb::Token,
     content: Herb::Token,
     tag_closing: Herb::Token,
+    prism_node: String,
   }
 
   type serialized_erb_in_node = serialized_node & {

data/src/analyze/action_view/tag_helper_node_builders.c

@@ -368,11 +368,14 @@ static AST_HTML_ATTRIBUTE_VALUE_NODE_T* create_interpolated_attribute_value(
     }
   }
 
+  token_T* open_quote = create_synthetic_token(allocator, "\"", TOKEN_QUOTE, start_position, start_position);
+  token_T* close_quote = create_synthetic_token(allocator, "\"", TOKEN_QUOTE, end_position, end_position);
+
   return ast_html_attribute_value_node_init(
-    NULL,
+    open_quote,
     value_children,
-    NULL,
-    false,
+    close_quote,
+    true,
     start_position,
     end_position,
     hb_array_init(0, allocator),

data/src/analyze/action_view/tag_helpers.c

@@ -132,6 +132,50 @@ static bool build_scope_options_from_context(
   return built;
 }
 
+static bool symbol_node_equals(pm_node_t* node, const char* name) {
+  if (!node || node->type != PM_SYMBOL_NODE) { return false; }
+
+  pm_symbol_node_t* symbol = (pm_symbol_node_t*) node;
+  size_t length = pm_string_length(&symbol->unescaped);
+
+  return length == strlen(name) && strncmp((const char*) pm_string_source(&symbol->unescaped), name, length) == 0;
+}
+
+static bool asset_tag_resolves_at_render_time(pm_call_node_t* call_node, const char* helper_name) {
+  bool is_stylesheet_link_tag = string_equals(helper_name, "stylesheet_link_tag");
+
+  if (!is_stylesheet_link_tag && !string_equals(helper_name, "javascript_include_tag")) { return false; }
+  if (!call_node || !call_node->arguments) { return false; }
+
+  pm_node_list_t* arguments = &call_node->arguments->arguments;
+
+  for (size_t i = 0; i < arguments->size; i++) {
+    pm_node_t* argument = arguments->nodes[i];
+
+    if (argument->type == PM_SPLAT_NODE || argument->type == PM_ARRAY_NODE) { return true; }
+
+    if (is_stylesheet_link_tag && i == 0
+        && (symbol_node_equals(argument, "all") || symbol_node_equals(argument, "app"))) {
+      return true;
+    }
+
+    if (argument->type != PM_KEYWORD_HASH_NODE) { continue; }
+
+    pm_keyword_hash_node_t* hash = (pm_keyword_hash_node_t*) argument;
+
+    for (size_t j = 0; j < hash->elements.size; j++) {
+      pm_node_t* element = hash->elements.nodes[j];
+      if (element->type != PM_ASSOC_NODE) { continue; }
+
+      pm_assoc_node_t* assoc = (pm_assoc_node_t*) element;
+
+      if (symbol_node_equals(assoc->key, "integrity") && assoc->value->type != PM_STRING_NODE) { return true; }
+    }
+  }
+
+  return false;
+}
+
 static tag_helper_parse_context_T* parse_tag_helper_content(
   const char* content_string,
   const char* original_source,
@@ -181,7 +225,8 @@ static tag_helper_parse_context_T* parse_tag_helper_content(
                                       .found = false };
   pm_visit_node(parse_context->root, search_tag_helper_node, &search);
 
-  if (!search.found) {
+  if (!search.found
+      || asset_tag_resolves_at_render_time(parse_context->info->call_node, search.matched_handler->name)) {
     tag_helper_info_free(&parse_context->info);
     pm_node_destroy(&parse_context->parser, parse_context->root);
     pm_parser_free(&parse_context->parser);
@@ -252,13 +297,17 @@ position_T byte_offset_to_position(const char* source, size_t offset) {
 
   if (!source) { return position; }
 
-  for (size_t i = 0; i < offset && source[i] != '\0'; i++) {
-    if (source[i] == '\n') {
-      position.line++;
-      position.column = 1;
-    } else if (!utf8_is_valid_continuation_byte((unsigned char) source[i])) {
-      position.column++;
-    }
+  const char* cursor = source;
+  const char* end = source + strnlen(source, offset);
+  const char* newline = NULL;
+
+  while ((newline = memchr(cursor, '\n', (size_t) (end - cursor))) != NULL) {
+    position.line++;
+    cursor = newline + 1;
+  }
+
+  for (; cursor < end; cursor++) {
+    if (!utf8_is_valid_continuation_byte((unsigned char) *cursor)) { position.column++; }
   }
 
   return position;
@@ -277,33 +326,40 @@ position_T prism_location_to_position_with_offset(
   size_t offset_in_erb = (size_t) (pm_location->start - erb_content_source);
   size_t total_offset = erb_content_offset + offset_in_erb;
 
-  size_t source_length = strlen(original_source);
-  if (total_offset > source_length) { return byte_offset_to_position(original_source, erb_content_offset); }
+  if (strnlen(original_source, total_offset) < total_offset) {
+    return byte_offset_to_position(original_source, erb_content_offset);
+  }
 
   return byte_offset_to_position(original_source, total_offset);
 }
 
 size_t calculate_byte_offset_from_position(const char* source, position_T position) {
   if (!source) { return 0; }
+  if (position.line == 0) { return strlen(source); }
+
+  const char* line_start = source;
+
+  for (uint32_t line = 1; line < position.line; line++) {
+    const char* newline = strchr(line_start, '\n');
 
-  size_t offset = 0;
-  uint32_t line = 1;
+    if (!newline) { return (size_t) (line_start - source) + strlen(line_start); }
+
+    line_start = newline + 1;
+  }
+
+  size_t offset = (size_t) (line_start - source);
   uint32_t column = 1;
 
   while (source[offset] != '\0') {
-    if (line == position.line && column == position.column) { return offset; }
+    if (column == position.column) { return offset; }
+    if (source[offset] == '\n') { break; }
 
-    if (source[offset] == '\n') {
-      line++;
-      column = 1;
-    } else if (!utf8_is_valid_continuation_byte((unsigned char) source[offset])) {
-      column++;
-    }
+    if (!utf8_is_valid_continuation_byte((unsigned char) source[offset])) { column++; }
 
     offset++;
   }
 
-  return offset;
+  return offset + strlen(source + offset);
 }
 
 static void prism_node_location_to_positions(

data/src/analyze/analyze.c

@@ -37,31 +37,11 @@
 static analyzed_ruby_T* herb_analyze_ruby(hb_string_T source) {
   analyzed_ruby_T* analyzed = init_analyzed_ruby(source);
 
-  pm_visit_node(analyzed->root, search_if_nodes, analyzed);
-  pm_visit_node(analyzed->root, search_block_nodes, analyzed);
-  pm_visit_node(analyzed->root, search_case_nodes, analyzed);
-  pm_visit_node(analyzed->root, search_case_match_nodes, analyzed);
-  pm_visit_node(analyzed->root, search_while_nodes, analyzed);
-  pm_visit_node(analyzed->root, search_for_nodes, analyzed);
-  pm_visit_node(analyzed->root, search_until_nodes, analyzed);
-  pm_visit_node(analyzed->root, search_begin_nodes, analyzed);
-  pm_visit_node(analyzed->root, search_unless_nodes, analyzed);
-  pm_visit_node(analyzed->root, search_when_nodes, analyzed);
-  pm_visit_node(analyzed->root, search_in_nodes, analyzed);
-
-  search_unexpected_elsif_nodes(analyzed);
-  search_unexpected_else_nodes(analyzed);
-  search_unexpected_end_nodes(analyzed);
-  search_unexpected_when_nodes(analyzed);
-  search_unexpected_in_nodes(analyzed);
-
-  search_unexpected_rescue_nodes(analyzed);
-  search_unexpected_ensure_nodes(analyzed);
-  search_yield_nodes(analyzed->root, analyzed);
-  search_then_keywords(analyzed->root, analyzed);
-  search_unexpected_block_closing_nodes(analyzed);
-
-  if (!analyzed->valid) { pm_visit_node(analyzed->root, search_unclosed_control_flows, analyzed); }
+  if (analyzed->valid) { return analyzed; }
+
+  pm_visit_node(analyzed->root, search_control_flow_nodes, analyzed);
+  search_unexpected_keyword_errors(analyzed);
+  pm_visit_node(analyzed->root, search_unclosed_control_flows, analyzed);
 
   return analyzed;
 }