nokogiri 1.19.4-java → 1.19.5-java

data/ext/nokogiri/gumbo.c

@@ -113,6 +113,71 @@ set_line(xmlNodePtr node, size_t line)
   }
 }
 
+// This function is essentially xmlNewNsProp, but we skip the full list traversal to append by
+// providing the last property in the linked list as a parameter.
+static xmlAttrPtr
+append_property(xmlNodePtr node, xmlNsPtr ns, const xmlChar *name, const xmlChar *value, xmlAttrPtr last_prop)
+{
+  xmlAttrPtr cur = (xmlAttrPtr) xmlMalloc(sizeof(xmlAttr));
+  if (cur == NULL) {
+    return NULL;
+  }
+  memset(cur, 0, sizeof(xmlAttr));
+  cur->type = XML_ATTRIBUTE_NODE;
+  cur->parent = node;
+  xmlDocPtr doc = node->doc;
+  cur->doc = doc;
+  cur->ns = ns;
+
+  if ((doc != NULL) && (doc->dict != NULL)) {
+    cur->name = (xmlChar *) xmlDictLookup(doc->dict, name, -1);
+  } else {
+    cur->name = xmlStrdup(name);
+  }
+  if (cur->name == NULL) {
+    goto error;
+  }
+
+  if (value != NULL) {
+    cur->children = xmlNewDocText(doc, value);
+    if (cur->children == NULL) {
+      goto error;
+    }
+    cur->last = NULL;
+    xmlNodePtr tmp = cur->children;
+    while (tmp != NULL) {
+      tmp->parent = (xmlNodePtr) cur;
+      if (tmp->next == NULL) {
+        cur->last = tmp;
+      }
+      tmp = tmp->next;
+    }
+
+    if (doc != NULL) {
+      int res = xmlIsID(doc, node, cur);
+      if (res < 0) {
+        goto error;
+      }
+      if ((res == 1) && (xmlAddIDSafe(cur, value) < 0)) {
+        goto error;
+      }
+    }
+  }
+
+  if (node->properties == NULL) {
+    node->properties = cur;
+  } else {
+    last_prop->next = cur;
+    cur->prev = last_prop;
+  }
+
+  return cur;
+
+error:
+  xmlFreeProp(cur);
+  return (NULL);
+}
+
 // Construct an XML tree rooted at xml_output_node from the Gumbo tree rooted
 // at gumbo_node.
 static void
@@ -200,6 +265,7 @@ build_tree(
         xmlAddChild(xml_node, xml_child);
 
         // Add the attributes.
+        xmlAttrPtr last_prop = NULL;
         const GumboVector *attrs = &gumbo_child->v.element.attributes;
         for (size_t i = 0; i < attrs->length; i++) {
           const GumboAttribute *attr = attrs->data[i];
@@ -220,7 +286,9 @@ build_tree(
             default:
               ns = NULL;
           }
-          xmlNewNsProp(xml_child, ns, (const xmlChar *)attr->name, (const xmlChar *)attr->value);
+
+          // We micromanage the attribute list for performance reasons.
+          last_prop = append_property(xml_child, ns, (const xmlChar *)attr->name, (const xmlChar *)attr->value, last_prop);
         }
 
         // Add children for this element.
@@ -373,12 +441,20 @@ parse_continue(VALUE parse_args)
   } else {
     doc = new_html_doc(NULL, NULL, NULL);
   }
-  args->doc = doc; // Make sure doc gets cleaned up if an error is thrown.
+
+  // We're about to build the libxml2 tree structure from the Gumbo tree
+  // structure. If an exception is raised during tree building, control passes
+  // to `parse_cleanup()` which needs to free the newly allocated `xmlDoc`,
+  // `doc`. If the tree is successfully constructed, then
+  // `noko_xml_document_wrap()` will create a new Ruby object which will own
+  // `doc`. In that case, `parse_cleanup()` should not free `doc`.
+  args->doc = doc;
   build_tree(doc, (xmlNodePtr)doc, output->document);
+  args->doc = NULL;
   VALUE rdoc = noko_xml_document_wrap(args->klass, doc);
+
   rb_iv_set(rdoc, "@url", args->url_or_frag);
   rb_iv_set(rdoc, "@quirks_mode", INT2NUM(output->document->v.document.doc_type_quirks_mode));
-  args->doc = NULL; // The Ruby runtime now owns doc so don't delete it.
   add_errors(output, rdoc, args->input, args->url_or_frag);
   return rdoc;
 }
@@ -512,6 +588,7 @@ error:
         continue;
       }
       VALUE element_name = rb_funcall(node, name, 0);
+      Check_Type(element_name, T_STRING);
       if (RSTRING_LEN(element_name) == 4
           && !st_strcasecmp(RSTRING_PTR(element_name), "form")
           && lookup_namespace(node, false) == GUMBO_NAMESPACE_HTML) {
@@ -568,7 +645,7 @@ error:
     .output = output,
     .input = tags,
     .url_or_frag = doc_fragment,
-    .doc = (xmlDocPtr)extract_xml_node(doc),
+    .doc = NULL,
   };
   rb_ensure(fragment_continue, (VALUE)(&args), parse_cleanup, (VALUE)(&args));
   return Qnil;
@@ -580,9 +657,9 @@ fragment_continue(VALUE parse_args)
   ParseArgs *args = (ParseArgs *)parse_args;
   GumboOutput *output = args->output;
   VALUE doc_fragment = args->url_or_frag;
-  xmlDocPtr xml_doc = args->doc;
+  VALUE doc = rb_funcall(doc_fragment, rb_intern_const("document"), 0);
+  xmlDocPtr xml_doc = (xmlDocPtr)extract_xml_node(doc);
 
-  args->doc = NULL; // The Ruby runtime owns doc so make sure we don't delete it.
   xmlNodePtr xml_frag = extract_xml_node(doc_fragment);
   build_tree(xml_doc, xml_frag, output->root);
   rb_iv_set(doc_fragment, "@quirks_mode", INT2NUM(output->document->v.document.doc_type_quirks_mode));

data/ext/nokogiri/html4_document.c

@@ -18,8 +18,8 @@ rb_html_document_s_new(int argc, VALUE *argv, VALUE klass)
   htmlDocPtr doc;
 
   rb_scan_args(argc, argv, "0*", &rest);
-  uri = rb_ary_entry(rest, (long)0);
-  external_id = rb_ary_entry(rest, (long)1);
+  uri = rb_ary_entry(rest, (rb_len_t)0);
+  external_id = rb_ary_entry(rest, (rb_len_t)1);
 
   doc = htmlNewDoc(
           RTEST(uri) ? (const xmlChar *)StringValueCStr(uri) : NULL,
@@ -48,10 +48,17 @@ rb_html_document_s_read_io(VALUE klass, VALUE rb_io, VALUE rb_url, VALUE rb_enco
 
   xmlSetStructuredErrorFunc((void *)rb_error_list, noko__error_array_pusher);
 
-  c_doc = htmlReadIO(noko_io_read, noko_io_close, (void *)rb_io, c_url, c_encoding, options);
+  noko_io_read_reset_exception();
+  c_doc = htmlReadIO(noko_io_read_protected, noko_io_close, (void *)rb_io, c_url, c_encoding, options);
+  VALUE rb_io_read_exception = noko_io_read_take_exception();
 
   xmlSetStructuredErrorFunc(NULL, NULL);
 
+  if (!NIL_P(rb_io_read_exception)) {
+    xmlFreeDoc(c_doc);
+    noko_io_read_raise_exception(rb_io_read_exception);
+  }
+
   /*
    * If EncodingFound has occurred in EncodingReader, make sure to do
    * a cleanup and propagate the error.

data/ext/nokogiri/libxml2_polyfill.c

@@ -112,3 +112,15 @@ xmlSwitchEncodingName(xmlParserCtxtPtr ctxt, const char *encoding)
   return (xmlSwitchToEncoding(ctxt, handler));
 }
 #endif
+
+#ifndef HAVE_XMLADDIDSAFE
+int
+xmlAddIDSafe(xmlAttrPtr attr, const xmlChar *value)
+{
+  xmlIDPtr id = xmlAddID(NULL, attr->doc, value, attr);
+  if (id) {
+    return 1;
+  }
+  return 0;
+}
+#endif

data/ext/nokogiri/nokogiri.c

@@ -50,7 +50,7 @@ void noko_init_html4_sax_parser(void);
 void noko_init_gumbo(void);
 void noko_init_test_global_handlers(void);
 
-static ID id_read, id_write, id_external_encoding;
+static ID id_read, id_write, id_external_encoding, id_io_read_exception;
 
 
 static VALUE
@@ -92,6 +92,87 @@ noko_io_read(void *io, char *c_buffer, int c_buffer_len)
 }
 
 
+typedef struct {
+  void *io;
+  char *c_buffer;
+  int c_buffer_len;
+  int n_bytes_read;
+} noko_io_read_args_t;
+
+static VALUE
+noko_io_read_call(VALUE data)
+{
+  noko_io_read_args_t *args = (noko_io_read_args_t *)data;
+  args->n_bytes_read = noko_io_read(args->io, args->c_buffer, args->c_buffer_len);
+  return Qnil;
+}
+
+
+/*
+ * Like noko_io_read, a StandardError raised by IO#read is swallowed, and libxml2 sees a read
+ * error. Any other exception (e.g., Interrupt or Timeout::ExitException) must not unwind through
+ * libxml2's stack frames, because that skips libxml2's cleanup and leaks memory, and skips the
+ * reset of the error handlers. So it is saved in a fiber-local variable, and $! is cleared until
+ * it is re-raised.
+ *
+ * A caller of libxml2 that passes this callback must call noko_io_read_reset_exception before
+ * calling libxml2, and noko_io_read_take_exception after libxml2 returns, and must re-raise a
+ * non-nil result with noko_io_read_raise_exception.
+ */
+int
+noko_io_read_protected(void *io, char *c_buffer, int c_buffer_len)
+{
+  noko_io_read_args_t args = { io, c_buffer, c_buffer_len, -1 };
+  int state = 0;
+
+  rb_protect(noko_io_read_call, (VALUE)&args, &state);
+
+  if (state) {
+    VALUE rb_errinfo_value = rb_errinfo();
+    if (RB_TYPE_P(rb_errinfo_value, T_OBJECT) && rb_obj_is_kind_of(rb_errinfo_value, rb_eException)) {
+      rb_set_errinfo(Qnil);
+    } else {
+      rb_errinfo_value = Qnil;
+    }
+    rb_thread_local_aset(rb_thread_current(), id_io_read_exception,
+                         rb_assoc_new(INT2FIX(state), rb_errinfo_value));
+    return -1;
+  }
+
+  return args.n_bytes_read;
+}
+
+
+void
+noko_io_read_reset_exception(void)
+{
+  rb_thread_local_aset(rb_thread_current(), id_io_read_exception, Qnil);
+}
+
+
+VALUE
+noko_io_read_take_exception(void)
+{
+  VALUE rb_thread = rb_thread_current();
+  VALUE rb_exception = rb_thread_local_aref(rb_thread, id_io_read_exception);
+
+  rb_thread_local_aset(rb_thread, id_io_read_exception, Qnil);
+  return rb_exception;
+}
+
+
+void
+noko_io_read_raise_exception(VALUE rb_exception)
+{
+  VALUE rb_errinfo_value = rb_ary_entry(rb_exception, 1);
+
+  if (!NIL_P(rb_errinfo_value)) {
+    rb_set_errinfo(rb_errinfo_value);
+  }
+  rb_jump_tag(FIX2INT(rb_ary_entry(rb_exception, 0)));
+}
+
+
 static VALUE
 noko_io_write_check(VALUE rb_args)
 {
@@ -122,7 +203,7 @@ noko_io_write(void *io, char *c_buffer, int c_buffer_len)
   io_encoding = RB_NIL_P(rb_enc) ? rb_ascii8bit_encoding() : rb_to_encoding(rb_enc);
 
   rb_args[0] = rb_io;
-  rb_args[1] = rb_enc_str_new(c_buffer, (long)c_buffer_len, io_encoding);
+  rb_args[1] = rb_enc_str_new(c_buffer, (rb_len_t)c_buffer_len, io_encoding);
 
   rb_n_bytes_written = rb_rescue(noko_io_write_check, (VALUE)rb_args, noko_io_write_failed, 0);
   if (rb_n_bytes_written == Qundef) { return -1; }
@@ -292,6 +373,7 @@ Init_nokogiri(void)
   noko_init_test_global_handlers();
 
   id_read = rb_intern("read");
+  id_io_read_exception = rb_intern("__nokogiri_io_read_exception");
   id_write = rb_intern("write");
   id_external_encoding = rb_intern("external_encoding");
 }

data/ext/nokogiri/xml_document.c

@@ -384,17 +384,24 @@ noko_xml_document_s_read_io(VALUE rb_class,
 
   const char *c_url    = NIL_P(rb_url)      ? NULL : StringValueCStr(rb_url);
   const char *c_enc    = NIL_P(rb_encoding) ? NULL : StringValueCStr(rb_encoding);
+  noko_io_read_reset_exception();
   xmlDocPtr c_document = xmlReadIO(
-                           (xmlInputReadCallback)noko_io_read,
+                           (xmlInputReadCallback)noko_io_read_protected,
                            (xmlInputCloseCallback)noko_io_close,
                            (void *)rb_io,
                            c_url,
                            c_enc,
                            (int)NUM2INT(rb_options)
                          );
+  VALUE rb_io_read_exception = noko_io_read_take_exception();
 
   noko__structured_error_func_restore(&handler_state);
 
+  if (!NIL_P(rb_io_read_exception)) {
+    xmlFreeDoc(c_document);
+    noko_io_read_raise_exception(rb_io_read_exception);
+  }
+
   if (c_document == NULL) {
     xmlFreeDoc(c_document);
 
@@ -464,7 +471,7 @@ new (int argc, VALUE *argv, VALUE klass)
   VALUE version, rest, rb_doc ;
 
   rb_scan_args(argc, argv, "0*", &rest);
-  version = rb_ary_entry(rest, (long)0);
+  version = rb_ary_entry(rest, (rb_len_t)0);
   if (NIL_P(version)) { version = rb_str_new2("1.0"); }
 
   doc = xmlNewDoc((xmlChar *)StringValueCStr(version));
@@ -609,7 +616,8 @@ rb_xml_document_canonicalize(int argc, VALUE *argv, VALUE self)
   VALUE rb_namespaces;
   VALUE rb_comments_p;
   int c_mode = 0;
-  xmlChar **c_namespaces;
+  xmlChar **c_namespaces = NULL;
+  VALUE rb_namespaces_buffer = 0;
 
   xmlDocPtr c_doc;
   xmlOutputBufferPtr c_obuf;
@@ -629,6 +637,35 @@ rb_xml_document_canonicalize(int argc, VALUE *argv, VALUE self)
     if (c_mode == XML_C14N_1_0 || c_mode == XML_C14N_1_1) {
       rb_raise(rb_eRuntimeError, "This canonicalizer does not support this operation");
     }
+
+    // Copy every prefix into one temporary buffer before libxml2 sees it. Converting first means a
+    // raise from #to_str or a null byte leaks nothing. Copying means GC compaction, which moves the
+    // bytes of embedded strings, cannot move a prefix while libxml2 reads it. No allocation may
+    // happen between reading a prefix's pointer and copying its bytes.
+    rb_len_t ns_len = RARRAY_LEN(rb_namespaces);
+    VALUE rb_prefixes = rb_ary_new_capa(ns_len);
+    for (rb_len_t j = 0; j < ns_len; j++) {
+      VALUE entry = rb_ary_entry(rb_namespaces, j);
+      StringValueCStr(entry);
+      rb_ary_push(rb_prefixes, entry);
+    }
+
+    size_t size = ((size_t)ns_len + 1) * sizeof(xmlChar *);
+    for (rb_len_t j = 0; j < ns_len; j++) {
+      size += (size_t)RSTRING_LEN(RARRAY_AREF(rb_prefixes, j)) + 1;
+    }
+    c_namespaces = ALLOCV(rb_namespaces_buffer, size);
+
+    xmlChar *c_prefix = (xmlChar *)(c_namespaces + ns_len + 1);
+    for (rb_len_t j = 0; j < ns_len; j++) {
+      VALUE prefix = RARRAY_AREF(rb_prefixes, j);
+      size_t prefix_len = (size_t)RSTRING_LEN(prefix);
+      memcpy(c_prefix, RSTRING_PTR(prefix), prefix_len);
+      c_prefix[prefix_len] = '\0';
+      c_namespaces[j] = c_prefix;
+      c_prefix += prefix_len + 1;
+    }
+    c_namespaces[ns_len] = NULL;
   }
 
   c_doc = noko_xml_document_unwrap(self);
@@ -646,24 +683,13 @@ rb_xml_document_canonicalize(int argc, VALUE *argv, VALUE self)
     rb_callback = (void *)rb_block_proc();
   }
 
-  if (NIL_P(rb_namespaces)) {
-    c_namespaces = NULL;
-  } else {
-    long ns_len = RARRAY_LEN(rb_namespaces);
-    c_namespaces = ruby_xcalloc((size_t)ns_len + 1, sizeof(xmlChar *));
-    for (int j = 0 ; j < ns_len ; j++) {
-      VALUE entry = rb_ary_entry(rb_namespaces, j);
-      c_namespaces[j] = (xmlChar *)StringValueCStr(entry);
-    }
-  }
-
   int ret = xmlC14NExecute(c_doc, c_callback_wrapper, rb_callback,
                            c_mode,
                            c_namespaces,
                            (int)RTEST(rb_comments_p),
                            c_obuf);
 
-  ruby_xfree(c_namespaces);
+  ALLOCV_END(rb_namespaces_buffer);
   xmlOutputBufferClose(c_obuf);
 
   if (ret < 0) {
@@ -733,7 +759,7 @@ noko_xml_document_has_wrapped_blank_nodes_p(xmlDocPtr c_document)
     return 0;
   }
 
-  for (long jnode = 0; jnode < RARRAY_LEN(cache); jnode++) {
+  for (rb_len_t jnode = 0; jnode < RARRAY_LEN(cache); jnode++) {
     xmlNodePtr node;
     VALUE element = rb_ary_entry(cache, jnode);
 

data/ext/nokogiri/xml_node.c

@@ -115,14 +115,10 @@ relink_namespace(xmlNodePtr reparented)
     xmlNsPtr prev = NULL;
 
     while (curr) {
-      xmlNsPtr ns = xmlSearchNsByHref(
-                      reparented->doc,
-                      reparented->parent,
-                      curr->href
-                    );
-      /* If we find the namespace is already declared, remove it from this
-       * definition list. */
-      if (ns && ns != curr && xmlStrEqual(ns->prefix, curr->prefix)) {
+      xmlNsPtr ns = xmlSearchNs(reparented->doc, reparented->parent, curr->prefix);
+      /* If the parent already binds this prefix to the same href, remove it
+       * from this definition list. */
+      if (ns && ns != curr && xmlStrEqual(ns->href, curr->href)) {
         if (prev) {
           prev->next = curr->next;
         } else {
@@ -1232,6 +1228,29 @@ namespaced_key_eh(VALUE self, VALUE attribute, VALUE namespace)
   return Qfalse;
 }
 
+/* If a matching attribute node already exists, then xmlSetNsProp will destroy
+ * the existing node's children. However, if Nokogiri has a node object
+ * pointing to one of those children, we are left with a broken reference.
+ *
+ * We can avoid this by unlinking these nodes first.
+ */
+static void
+unlink_wrapped_attr_children(xmlAttrPtr attr)
+{
+  xmlNodePtr cur, next;
+
+  if (!attr || attr->type != XML_ATTRIBUTE_NODE) {
+    return;
+  }
+  for (cur = attr->children; cur; cur = next) {
+    next = cur->next;
+    if (cur->_private) {
+      noko_xml_document_pin_node(cur);
+      xmlUnlinkNode(cur);
+    }
+  }
+}
+
 /*
  * call-seq:
  *  []=(property, value)
@@ -1241,31 +1260,36 @@ namespaced_key_eh(VALUE self, VALUE attribute, VALUE namespace)
 static VALUE
 set(VALUE self, VALUE property, VALUE value)
 {
-  xmlNodePtr node, cur;
-  xmlAttrPtr prop;
+  xmlNodePtr node;
+  xmlNsPtr ns = NULL;
+  const xmlChar *name, *local_name, *c_value;
+  xmlChar *prefix;
+  int prefix_len;
   Noko_Node_Get_Struct(self, xmlNode, node);
 
-  /* If a matching attribute node already exists, then xmlSetProp will destroy
-   * the existing node's children. However, if Nokogiri has a node object
-   * pointing to one of those children, we are left with a broken reference.
-   *
-   * We can avoid this by unlinking these nodes first.
-   */
   if (node->type != XML_ELEMENT_NODE) {
     return (Qnil);
   }
-  prop = xmlHasProp(node, (xmlChar *)StringValueCStr(property));
-  if (prop && prop->children) {
-    for (cur = prop->children; cur; cur = cur->next) {
-      if (cur->_private) {
-        noko_xml_document_pin_node(cur);
-        xmlUnlinkNode(cur);
-      }
+  name = (const xmlChar *)StringValueCStr(property);
+  c_value = (const xmlChar *)StringValueCStr(value);
+
+  /* Resolve a QName the way xmlSetProp does, so that we find the same attribute it would replace. */
+  local_name = xmlSplitQName3(name, &prefix_len);
+  if (local_name) {
+    prefix = xmlStrndup(name, prefix_len);
+    if (!prefix) {
+      rb_memerror();
     }
+    ns = xmlSearchNs(node->doc, node, prefix);
+    xmlFree(prefix);
+  }
+  if (!ns) {
+    local_name = name;
   }
 
-  xmlSetProp(node, (xmlChar *)StringValueCStr(property),
-             (xmlChar *)StringValueCStr(value));
+  unlink_wrapped_attr_children(xmlHasNsProp(node, local_name, ns ? ns->href : NULL));
+
+  xmlSetNsProp(node, ns, local_name, c_value);
 
   return value;
 }
@@ -1338,6 +1362,11 @@ set_namespace(VALUE self, VALUE namespace)
 
   xmlSetNs(node, ns);
 
+  if (ns && node->type == XML_ELEMENT_NODE && !xmlSearchNs(node->doc, node, ns->prefix)) {
+    xmlNsPtr definition = xmlNewNs(node, ns->href, ns->prefix);
+    if (definition) { xmlSetNs(node, definition); }
+  }
+
   return self;
 }
 
@@ -1566,6 +1595,7 @@ set_lang(VALUE self_rb, VALUE lang_rb)
   Noko_Node_Get_Struct(self_rb, xmlNode, self);
   lang = (xmlChar *)StringValueCStr(lang_rb);
 
+  unlink_wrapped_attr_children(xmlHasNsProp(self, BAD_CAST "lang", XML_XML_NAMESPACE));
   xmlNodeSetLang(self, lang);
 
   return Qnil ;
@@ -1744,7 +1774,7 @@ static inline void
 output_partial_string(VALUE out, char const *str, size_t length)
 {
   if (length) {
-    rb_enc_str_buf_cat(out, str, (long)length, rb_utf8_encoding());
+    rb_enc_str_buf_cat(out, str, (rb_len_t)length, rb_utf8_encoding());
   }
 }
 
@@ -1834,9 +1864,9 @@ output_escaped_string(VALUE out, xmlChar const *start, bool attr)
       replaced_bytes = 2;
     } else if (attr && ch == '"') {
       replacement = """;
-    } else if (!attr && ch == '<') {
+    } else if (ch == '<') {
       replacement = "&lt;";
-    } else if (!attr && ch == '>') {
+    } else if (ch == '>') {
       replacement = "&gt;";
     } else {
       ++next;
@@ -1897,7 +1927,8 @@ static void
 output_node(
   VALUE out,
   xmlNodePtr node,
-  bool preserve_newline
+  bool preserve_newline,
+  bool scripting_enabled
 )
 {
   static char const *const VOID_ELEMENTS[] = {
@@ -1906,9 +1937,11 @@ output_node(
   };
 
   static char const *const UNESCAPED_TEXT_ELEMENTS[] = {
-    "style", "script", "xmp", "iframe", "noembed", "noframes", "plaintext", "noscript",
+    "style", "script", "xmp", "iframe", "noembed", "noframes", "plaintext",
   };
 
+  static char const *const NOSCRIPT_ELEMENT[] = { "noscript" };
+
   switch (node->type) {
     case XML_ELEMENT_NODE:
       // Serialize the start tag.
@@ -1918,7 +1951,7 @@ output_node(
       // Add attributes.
       for (xmlAttrPtr attr = node->properties; attr; attr = attr->next) {
         output_char(out, ' ');
-        output_node(out, (xmlNodePtr)attr, preserve_newline);
+        output_node(out, (xmlNodePtr)attr, preserve_newline, scripting_enabled);
       }
       output_char(out, '>');
 
@@ -1928,7 +1961,7 @@ output_node(
           output_char(out, '\n');
         }
         for (xmlNodePtr child = node->children; child; child = child->next) {
-          output_node(out, child, preserve_newline);
+          output_node(out, child, preserve_newline, scripting_enabled);
         }
         output_string(out, "</");
         output_tagname(out, node);
@@ -1954,8 +1987,9 @@ output_node(
 
     case XML_TEXT_NODE:
       if (node->parent
-          && is_one_of(node->parent, UNESCAPED_TEXT_ELEMENTS,
-                       sizeof UNESCAPED_TEXT_ELEMENTS / sizeof UNESCAPED_TEXT_ELEMENTS[0])) {
+          && (is_one_of(node->parent, UNESCAPED_TEXT_ELEMENTS,
+                        sizeof UNESCAPED_TEXT_ELEMENTS / sizeof UNESCAPED_TEXT_ELEMENTS[0])
+              || (scripting_enabled && is_one_of(node->parent, NOSCRIPT_ELEMENT, 1)))) {
         output_string(out, (char const *)node->content);
       } else {
         output_escaped_string(out, node->content, false);
@@ -1991,7 +2025,7 @@ output_node(
     case XML_DOCUMENT_FRAG_NODE:
     case XML_HTML_DOCUMENT_NODE:
       for (xmlNodePtr child = node->children; child; child = child->next) {
-        output_node(out, child, preserve_newline);
+        output_node(out, child, preserve_newline, scripting_enabled);
       }
       break;
 
@@ -2004,13 +2038,14 @@ output_node(
 static VALUE
 html_standard_serialize(
   VALUE self,
-  VALUE preserve_newline
+  VALUE preserve_newline,
+  VALUE scripting_enabled
 )
 {
   xmlNodePtr node;
   Noko_Node_Get_Struct(self, xmlNode, node);
   VALUE output = rb_str_buf_new(4096);
-  output_node(output, node, RTEST(preserve_newline));
+  output_node(output, node, RTEST(preserve_newline), RTEST(scripting_enabled));
   return output;
 }
 
@@ -2512,7 +2547,7 @@ noko_init_xml_node(void)
   rb_define_private_method(cNokogiriXmlNode, "in_context", in_context, 2);
   rb_define_private_method(cNokogiriXmlNode, "native_write_to", native_write_to, 4);
   rb_define_private_method(cNokogiriXmlNode, "prepend_newline?", rb_prepend_newline, 0);
-  rb_define_private_method(cNokogiriXmlNode, "html_standard_serialize", html_standard_serialize, 1);
+  rb_define_private_method(cNokogiriXmlNode, "html_standard_serialize", html_standard_serialize, 2);
   rb_define_private_method(cNokogiriXmlNode, "process_xincludes", noko_xml_node__process_xincludes, 1);
   rb_define_private_method(cNokogiriXmlNode, "replace_node", replace, 1);
   rb_define_private_method(cNokogiriXmlNode, "set", set, 2);