From e15381c1cb5e828d302c9d3333857c2d7839bdc6 Mon Sep 17 00:00:00 2001
From: Wilson Lin <code@wilsonl.in>
Date: Fri, 27 Dec 2019 21:52:49 +1100
Subject: [PATCH] Handle text script content

---
 {src/spec/tag => archive}/child/blacklist.c  |   0
 {src/spec/tag => archive}/child/whitelist.c  |   0
 {src/spec/tag => archive}/parent/blacklist.c |   0
 {src/spec/tag => archive}/parent/whitelist.c |   0
 notes/Processing.md                          |  14 ++-
 notes/Tag omission.md                        |  19 ---
 notes/Text script content.md                 | 125 +++++++++++++++++++
 src/proc.rs                                  |  23 +++-
 src/unit/attr/mod.rs                         |  30 +++--
 src/unit/attr/value.rs                       |  12 +-
 src/unit/{script.rs => script/js.rs}         |   6 +-
 src/unit/script/mod.rs                       |   2 +
 src/unit/script/text.rs                      |  37 ++++++
 src/unit/tag.rs                              |  43 ++++++-
 14 files changed, 257 insertions(+), 54 deletions(-)
 rename {src/spec/tag => archive}/child/blacklist.c (100%)
 rename {src/spec/tag => archive}/child/whitelist.c (100%)
 rename {src/spec/tag => archive}/parent/blacklist.c (100%)
 rename {src/spec/tag => archive}/parent/whitelist.c (100%)
 delete mode 100644 notes/Tag omission.md
 create mode 100644 notes/Text script content.md
 rename src/unit/{script.rs => script/js.rs} (92%)
 create mode 100644 src/unit/script/mod.rs
 create mode 100644 src/unit/script/text.rs

diff --git a/src/spec/tag/child/blacklist.c b/archive/child/blacklist.c
similarity index 100%
rename from src/spec/tag/child/blacklist.c
rename to archive/child/blacklist.c
diff --git a/src/spec/tag/child/whitelist.c b/archive/child/whitelist.c
similarity index 100%
rename from src/spec/tag/child/whitelist.c
rename to archive/child/whitelist.c
diff --git a/src/spec/tag/parent/blacklist.c b/archive/parent/blacklist.c
similarity index 100%
rename from src/spec/tag/parent/blacklist.c
rename to archive/parent/blacklist.c
diff --git a/src/spec/tag/parent/whitelist.c b/archive/parent/whitelist.c
similarity index 100%
rename from src/spec/tag/parent/whitelist.c
rename to archive/parent/whitelist.c
diff --git a/notes/Processing.md b/notes/Processing.md
index e7ab5f9..ff813ab 100644
--- a/notes/Processing.md
+++ b/notes/Processing.md
@@ -2,16 +2,18 @@
 
 ## Redundant requires
 
-Sometimes the code will look like it duplicates matching logic. For example:
+Sometimes the code will look like it does redundant matching logic. For example:
 
 ```rust
-fn process_comment(proc: &mut Proc) -> () {
-	proc.matches("<!--").require_reason("comment").skip();
+pub fn process_comment(proc: &mut Processor) -> ProcessingResult<()> {
+    chain!(proc.match_seq(b"<!--").expect().discard());
 
-	proc.while_not_matches("-->").skip();
+    chain!(proc.match_while_not_seq(&SinglePattern::new(b"-->")).discard());
 
-	proc.matches("-->").require_reason("comment end").skip();
+    chain!(proc.match_seq(b"-->").require_with_reason("comment end")?.discard());
+
+    Ok(())
 }
 ```
 
-At first glance, it might appear that the second call `while_not_matches` makes it redundant to require it again immediately afterwards. However, it's possible that the `while_not_matches` actually stops for some other reason, such as reaching EOF. Even if it's guaranteed, it's still nice to have a declared invariant, like an assertion statement.
+At first glance, it might appear that the second call `match_while_not_seq` makes it redundant to require it again immediately afterwards. However, it's possible that the `match_while_not_seq` actually stops for some other reason, such as reaching EOF. Even if it's guaranteed, it's still nice to have a declared invariant, like an assertion statement.
diff --git a/notes/Tag omission.md b/notes/Tag omission.md
deleted file mode 100644
index 8fb3f3b..0000000
--- a/notes/Tag omission.md	
+++ /dev/null
@@ -1,19 +0,0 @@
-# Tag omission
-
-|Tag name|Details|
-|---|---|
-|`li`| The end tag can be omitted if the list item is immediately followed by another `<li>` element, or if there is no more content in its parent element.|
-|`p`| The start tag is required. The end tag may be omitted if the `<p>` element is immediately followed by an `<address>`, `<article>`, `<aside>`, `<blockquote>`, `<div>`, `<dl>`, `<fieldset>`, `<footer>`, `<form>`, `<h1>`, `<h2>`, `<h3>`, `<h4>`, `<h5>`, `<h6>`, `<header>`, `<hr>`, `<menu>`, `<nav>`, `<ol>`, `<pre>`, `<section>`, `<table>`, `<ul>` or another `<p>` element, or if there is no more content in the parent element and the parent element is not an `<a>` element.|
-|`rp`| The end tag can be omitted if the element is immediately followed by an `<rt>` or another `<rp>` element, or if there is no more content in the parent element.|
-|`rt`| The end tag may be omitted if the `<rt>` element is immediately followed by an `<rt>` or `<rp>` element, or if there is no more content in the parent element.|
-|`rtc`| The closing tag can be omitted if it is immediately followed by a `<rb>`, `<rtc>` or `<rt>` element opening tag or by its parent closing tag.|
-|`caption`| The end tag can be omitted if the element is not immediately followed by ASCII whitespace or a comment.|
-|`colgroup`| The start tag may be omitted, if it has a `<col>` element as its first child and if it is not preceded by a `<colgroup>` whose end tag has been omitted. The end tag may be omitted, if it is not followed by a space or a comment.|
-|`tbody`| The `<tbody>` element is not a required child element for a parent `<table>` element to graphically render. However, it must not be present, if its parent `<table>` element has a `<tr>` element as a child.|
-|`td`| The start tag is mandatory. The end tag may be omitted, if it is immediately followed by a `<th>` or `<td>` element or if there are no more data in its parent element.|
-|`tfoot`|The start tag is mandatory. The end tag may be omitted if there is no more content in the parent `<table>` element.|
-|`th`|The start tag is mandatory. The end tag may be omitted, if it is immediately followed by a `<th>` or `<td>` element or if there are no more data in its parent element.|
-|`thead`|The start tag is mandatory. The end tag may be omitted if the `<thead>` element is immediately followed by a `<tbody>` or `<tfoot>` element.|
-|`tr`|Start tag is mandatory. End tag may be omitted if the `<tr>` element is immediately followed by a `<tr>` element, or if the row is the last element in its parent table group (`<thead>`, `<tbody>` or `<tfoot>`) element.|
-|`optgroup`|The start tag is mandatory. The end tag is optional if this element is immediately followed by another `<optgroup>` element, or if the parent element has no more content.|
-|`option`|The start tag is mandatory. The end tag is optional if this element is immediately followed by another `<option>` element or an `<optgroup>`, or if the parent element has no more content.|
diff --git a/notes/Text script content.md b/notes/Text script content.md
new file mode 100644
index 0000000..b0f8147
--- /dev/null
+++ b/notes/Text script content.md	
@@ -0,0 +1,125 @@
+# Text script content
+
+```html
+<script type="text/html">
+  <script>
+    exec1 = true;
+  </script>
+  <script>
+    exec2 = true;
+  </script>
+</script>
+```
+These are true about the above snippet:
+- `document.querySelectorAll('script').length === 2`.
+- `!exec1 && exec2`.
+- `document.querySelector('script[type="text/html"]')` has exactly one child node and it's a text node.
+
+## Comments
+
+If there is one or more `<script>` inside an HTML comment before any `</script>`, the first `</script>` will not end the main script.
+
+### Examples
+
+Ending tag inside comment works because there are no nested script tags.
+
+```html
+<script type="text/plain"><!--
+</script>
+```
+
+There is a nested tag but it doesn't need to be closed because it's treated as text.
+
+```html
+<script type="text/plain">
+  <script>
+</script>
+```
+
+There is a nested tag but it doesn't need to be closed because it's not inside an HTML comment.
+
+```html
+<script type="text/plain">
+  <script><!--
+</script>
+```
+
+There is a nested tag but it doesn't need to be closed because main closing tag is not inside an HTML comment.
+
+```html
+<script type="text/plain"><!--
+  <script>-->
+</script>
+```
+
+The main closing tag is in a HTML comment but still works because there is no `<script>` before it in its comment (there is one in the previous comment).
+
+```html
+<script type="text/plain">
+    <!--<script>--><!--
+</script>
+```
+
+There is a nested tag and it's in an HTML comment but it doesn't need to be closed because it's not `script`.
+
+```html
+<script type="text/plain"><!--
+  <div>
+</script>
+```
+
+First closing tag is inside a comment with one or more previous opening tags so it doesn't close main script tag.
+
+```html
+<script type="text/plain"><!--
+  <script>alert();</script>
+</script>
+```
+
+There is a nested tag and it needs to be closed because it's in a comment `script`. The amount of `<script>` doesn't matter.
+
+```html
+<script type="text/plain"><!--
+  <script><script><script><script><script>alert();</script>
+</script>
+```
+
+First and second closing tags close their respective previous 1+ opening tags.
+
+```html
+<script type="text/plain"><!--
+  <script><script><script>alert();</script>
+  <script></script>
+</script>
+```
+
+Main closing tag works because it is in a separate comment.
+
+```html
+<script type="text/plain">
+  <!--<script><script><script>--><!--
+</script>
+```
+
+Main closing tag works because it is not in a comment.
+
+```html
+<script type="text/plain">
+  <!--<script>-->
+</script>
+```
+
+Figure this out:
+
+```html
+<script type="text/plain"><!--
+  <script>
+    alert();
+  </script>
+  </script
+  <script>
+    alert();
+  </script>
+</script>
+<h1>Test</h1>
+```
diff --git a/src/proc.rs b/src/proc.rs
index 97b701a..5f1317e 100644
--- a/src/proc.rs
+++ b/src/proc.rs
@@ -48,11 +48,25 @@ pub struct ProcessorRange {
     end: usize,
 }
 
+impl ProcessorRange {
+    pub fn len(&self) -> usize {
+        self.end - self.start
+    }
+    pub fn empty(&self) -> bool {
+        self.start >= self.end
+    }
+}
+
 // Processing state of a file. Most fields are used internally and set during
 // processing. Single use only; create one per processing.
 pub struct Processor<'d> {
     code: &'d mut [u8],
 
+    // Index of the next character to read.
+    read_next: usize,
+    // Index of the next unwritten space.
+    write_next: usize,
+
     // Match.
     // Need to record start as we might get slice after keeping or skipping.
     match_start: usize,
@@ -63,11 +77,6 @@ pub struct Processor<'d> {
     // Character matched, if any. Only exists for single-character matches and if matched.
     match_char: Option<u8>,
     match_reason: RequireReason,
-
-    // Index of the next character to read.
-    read_next: usize,
-    // Index of the next unwritten space.
-    write_next: usize,
 }
 
 impl<'d> Index<ProcessorRange> for Processor<'d> {
@@ -314,6 +323,10 @@ impl<'d> Processor<'d> {
     pub fn erase_written(&mut self, checkpoint: Checkpoint) -> () {
         self.write_next = checkpoint.write_next;
     }
+    /// Get written characters since checkpoint as range.
+    pub fn written_range(&self, checkpoint: Checkpoint) -> ProcessorRange {
+        ProcessorRange { start: checkpoint.write_next, end: self.write_next }
+    }
     /// Get amount of source characters consumed since checkpoint.
     pub fn consumed_count(&self, checkpoint: Checkpoint) -> usize {
         self.read_next - checkpoint.read_next
diff --git a/src/unit/attr/mod.rs b/src/unit/attr/mod.rs
index 172e9fb..c6458fd 100644
--- a/src/unit/attr/mod.rs
+++ b/src/unit/attr/mod.rs
@@ -1,7 +1,7 @@
 use phf::{phf_set, Set};
 
 use crate::err::ProcessingResult;
-use crate::proc::Processor;
+use crate::proc::{Processor, ProcessorRange};
 use crate::spec::codepoint::is_control;
 use crate::unit::attr::value::{DelimiterType, process_attr_value, ProcessedAttrValue};
 
@@ -18,6 +18,12 @@ pub enum AttrType {
     NoValue,
 }
 
+pub struct ProcessedAttr {
+    pub name: ProcessorRange,
+    pub typ: AttrType,
+    pub value: Option<ProcessorRange>,
+}
+
 // Characters allowed in an attribute name.
 // NOTE: Unicode noncharacters not tested.
 // See https://html.spec.whatwg.org/multipage/syntax.html#syntax-attribute-name for spec.
@@ -28,26 +34,28 @@ fn is_name_char(c: u8) -> bool {
     }
 }
 
-pub fn process_attr(proc: &mut Processor) -> ProcessingResult<AttrType> {
+pub fn process_attr(proc: &mut Processor) -> ProcessingResult<ProcessedAttr> {
     // Expect `process_attr` to be called at an attribute.
-    let name = chain!(proc.match_while_pred(is_name_char).expect().keep().slice());
+    let name = chain!(proc.match_while_pred(is_name_char).expect().keep().range());
     let after_name = proc.checkpoint();
 
     // TODO DOC Attr must be case sensitive
-    let should_collapse_and_trim_value_ws = COLLAPSIBLE_AND_TRIMMABLE_ATTRS.contains(name);
+    let should_collapse_and_trim_value_ws = COLLAPSIBLE_AND_TRIMMABLE_ATTRS.contains(&proc[name]);
     let has_value = chain!(proc.match_char(b'=').keep().matched());
 
-    if !has_value {
-        Ok(AttrType::NoValue)
+    let (typ, value) = if !has_value {
+        (AttrType::NoValue, None)
     } else {
         match process_attr_value(proc, should_collapse_and_trim_value_ws)? {
-            ProcessedAttrValue { empty: true, .. } => {
+            ProcessedAttrValue { value: None, .. } => {
                 // Value is empty, which is equivalent to no value, so discard `=` and any quotes.
                 proc.erase_written(after_name);
-                Ok(AttrType::NoValue)
+                (AttrType::NoValue, None)
             }
-            ProcessedAttrValue { delimiter: DelimiterType::Unquoted, .. } => Ok(AttrType::Unquoted),
-            ProcessedAttrValue { delimiter: DelimiterType::Double, .. } | ProcessedAttrValue { delimiter: DelimiterType::Single, .. } => Ok(AttrType::Quoted),
+            ProcessedAttrValue { delimiter: DelimiterType::Unquoted, value } => (AttrType::Unquoted, value),
+            ProcessedAttrValue { delimiter: DelimiterType::Double, value } | ProcessedAttrValue { delimiter: DelimiterType::Single, value } => (AttrType::Quoted, value),
         }
-    }
+    };
+
+    Ok(ProcessedAttr { name, typ, value })
 }
diff --git a/src/unit/attr/value.rs b/src/unit/attr/value.rs
index ac33619..33c5ab3 100644
--- a/src/unit/attr/value.rs
+++ b/src/unit/attr/value.rs
@@ -1,7 +1,7 @@
 use phf::{Map, phf_map};
 
 use crate::err::ProcessingResult;
-use crate::proc::Processor;
+use crate::proc::{Processor, ProcessorRange};
 use crate::spec::codepoint::is_whitespace;
 use crate::unit::entity::{EntityType, maybe_process_entity, ParsedEntity};
 
@@ -216,7 +216,7 @@ macro_rules! consume_attr_value_chars {
 
 pub struct ProcessedAttrValue {
     pub delimiter: DelimiterType,
-    pub empty: bool,
+    pub value: Option<ProcessorRange>,
 }
 
 pub fn process_attr_value(proc: &mut Processor, should_collapse_and_trim_ws: bool) -> ProcessingResult<ProcessedAttrValue> {
@@ -229,7 +229,7 @@ pub fn process_attr_value(proc: &mut Processor, should_collapse_and_trim_ws: boo
     };
 
     // Stage 1: read and collect metrics on attribute value characters.
-    let value_start_checkpoint = proc.checkpoint();
+    let src_value_checkpoint = proc.checkpoint();
     let mut metrics = Metrics {
         count_double_quotation: 0,
         count_single_quotation: 0,
@@ -245,7 +245,7 @@ pub fn process_attr_value(proc: &mut Processor, should_collapse_and_trim_ws: boo
     });
 
     // Stage 2: optimally minify attribute value using metrics.
-    proc.restore(value_start_checkpoint);
+    proc.restore(src_value_checkpoint);
     let optimal_delimiter = metrics.get_optimal_delimiter_type();
     let optimal_delimiter_char = match optimal_delimiter {
         DelimiterType::Double => Some(b'"'),
@@ -259,6 +259,7 @@ pub fn process_attr_value(proc: &mut Processor, should_collapse_and_trim_ws: boo
     let mut char_type;
     // Used to determine first and last characters.
     let mut char_no = 0usize;
+    let processed_value_checkpoint = proc.checkpoint();
     consume_attr_value_chars!(proc, should_collapse_and_trim_ws, src_delimiter_pred, char_type, {
         match char_type {
             // This should never happen.
@@ -293,6 +294,7 @@ pub fn process_attr_value(proc: &mut Processor, should_collapse_and_trim_ws: boo
         };
         char_no += 1;
     });
+    let processed_value_range = proc.written_range(processed_value_checkpoint);
     // Ensure closing delimiter in src has been matched and discarded, if any.
     if let Some(c) = src_delimiter {
         chain!(proc.match_char(c).expect().discard());
@@ -304,6 +306,6 @@ pub fn process_attr_value(proc: &mut Processor, should_collapse_and_trim_ws: boo
 
     Ok(ProcessedAttrValue {
         delimiter: optimal_delimiter,
-        empty: metrics.collected_count == 0,
+        value: Some(processed_value_range).filter(|r| !r.empty()),
     })
 }
diff --git a/src/unit/script.rs b/src/unit/script/js.rs
similarity index 92%
rename from src/unit/script.rs
rename to src/unit/script/js.rs
index e5bc3a8..ee051e6 100644
--- a/src/unit/script.rs
+++ b/src/unit/script/js.rs
@@ -9,7 +9,7 @@ fn parse_comment_single(proc: &mut Processor) -> ProcessingResult<()> {
     chain!(proc.match_seq(b"//").expect().keep());
 
     // Comment can end at closing </script>.
-    // WARNING: Closing tag must not contain whitespace.
+    // TODO WARNING: Closing tag must not contain whitespace.
     // TODO Optimise
     while !chain!(proc.match_line_terminator().keep().matched()) {
         if chain!(proc.match_seq(b"</script>").matched()) {
@@ -26,7 +26,7 @@ fn parse_comment_multi(proc: &mut Processor) -> ProcessingResult<()> {
     chain!(proc.match_seq(b"/*").expect().keep());
 
     // Comment can end at closing </script>.
-    // WARNING: Closing tag must not contain whitespace.
+    // TODO WARNING: Closing tag must not contain whitespace.
     // TODO Optimise
     while !chain!(proc.match_seq(b"*/").keep().matched()) {
         if chain!(proc.match_seq(b"</script>").matched()) {
@@ -91,7 +91,7 @@ fn parse_template(proc: &mut Processor) -> ProcessingResult<()> {
     Ok(())
 }
 
-pub fn process_script(proc: &mut Processor) -> ProcessingResult<()> {
+pub fn process_js_script(proc: &mut Processor) -> ProcessingResult<()> {
     while !chain!(proc.match_seq(b"</").matched()) {
         if chain!(proc.match_seq(b"//").matched()) {
             parse_comment_single(proc)?;
diff --git a/src/unit/script/mod.rs b/src/unit/script/mod.rs
new file mode 100644
index 0000000..ce1db0b
--- /dev/null
+++ b/src/unit/script/mod.rs
@@ -0,0 +1,2 @@
+pub mod js;
+pub mod text;
diff --git a/src/unit/script/text.rs b/src/unit/script/text.rs
new file mode 100644
index 0000000..cdbe322
--- /dev/null
+++ b/src/unit/script/text.rs
@@ -0,0 +1,37 @@
+use crate::proc::Processor;
+use crate::err::ProcessingResult;
+use crate::spec::codepoint::is_whitespace;
+
+pub fn process_text_script(proc: &mut Processor) -> ProcessingResult<()> {
+    // NOTE: See "notes/Text script content.md".
+    let mut in_comment = false;
+    let mut comment_has_unclosed_script = false;
+    loop {
+        // TODO Optimise
+        if chain!(proc.match_seq(b"<!--").keep().matched()) {
+            // NOTE: Could already be in comment, so don't reset `comment_has_unclosed_script`.
+            in_comment = true;
+        } else if chain!(proc.match_seq(b"-->").keep().matched()) {
+            comment_has_unclosed_script = false;
+            in_comment = false;
+        } else if in_comment && chain!(proc.match_seq(b"<script").keep().matched()) {
+            // TODO DOC Case sensitive, no space before tag name, nothing else in tag.
+            // TODO Opening tag can have attributes, whitespace, etc.
+            chain!(proc.match_char(b'>').require().keep());
+            comment_has_unclosed_script = true;
+        } else if chain!(proc.match_seq(b"</script").matched()) {
+            // TODO DOC Case sensitive, no space before tag name, nothing else in tag.
+            if !comment_has_unclosed_script {
+                break;
+            }
+            comment_has_unclosed_script = false;
+            // Keep previously matched closing tag start.
+            proc.keep();
+            // TODO Close tag can have whitespace.
+            chain!(proc.match_char(b'>').require().keep());
+        } else {
+            proc.accept()?;
+        };
+    };
+    Ok(())
+}
diff --git a/src/unit/tag.rs b/src/unit/tag.rs
index 82f87c6..2e43bdd 100644
--- a/src/unit/tag.rs
+++ b/src/unit/tag.rs
@@ -1,11 +1,32 @@
 use crate::err::{ErrorType, ProcessingResult};
-use crate::proc::Processor;
+use crate::proc::{Processor, ProcessorRange};
 use crate::spec::codepoint::{is_alphanumeric, is_whitespace};
 use crate::spec::tag::void::VOID_TAGS;
-use crate::unit::attr::{AttrType, process_attr};
+use crate::unit::attr::{AttrType, process_attr, ProcessedAttr};
 use crate::unit::content::process_content;
-use crate::unit::script::process_script;
 use crate::unit::style::process_style;
+use phf::{Set, phf_set};
+use crate::unit::script::text::process_text_script;
+use crate::unit::script::js::process_js_script;
+
+pub static JAVASCRIPT_MIME_TYPES: Set<&'static [u8]> = phf_set! {
+    b"application/ecmascript",
+    b"application/javascript",
+    b"application/x-ecmascript",
+    b"application/x-javascript",
+    b"text/ecmascript",
+    b"text/javascript",
+    b"text/javascript1.0",
+    b"text/javascript1.1",
+    b"text/javascript1.2",
+    b"text/javascript1.3",
+    b"text/javascript1.4",
+    b"text/javascript1.5",
+    b"text/jscript",
+    b"text/livescript",
+    b"text/x-ecmascript",
+    b"text/x-javascript",
+};
 
 // Tag names may only use ASCII alphanumerics. However, some people also use `:` and `-`.
 // See https://html.spec.whatwg.org/multipage/syntax.html#syntax-tag-name for spec.
@@ -36,6 +57,8 @@ pub fn process_tag(proc: &mut Processor) -> ProcessingResult<()> {
 
     let mut last_attr_type: Option<AttrType> = None;
     let mut self_closing = false;
+    // Value of any "type" attribute; if multiple, last kept.
+    let mut attr_type_value: Option<ProcessorRange> = None;
 
     loop {
         // At the beginning of this loop, the last parsed unit was either the tag name or an attribute (including its value, if it had one).
@@ -57,12 +80,18 @@ pub fn process_tag(proc: &mut Processor) -> ProcessingResult<()> {
         }
 
         // Write space after tag name or unquoted/valueless attribute.
+        // Don't write after unquoted.
         match last_attr_type {
             Some(AttrType::Unquoted) | Some(AttrType::NoValue) | None => proc.write(b' '),
             _ => {}
         };
 
-        last_attr_type = Some(process_attr(proc)?);
+        let ProcessedAttr { name, typ, value } = process_attr(proc)?;
+        match &proc[name] {
+            b"type" => attr_type_value = value,
+            _ => {},
+        };
+        last_attr_type = Some(typ);
     };
 
     if self_closing || VOID_TAGS.contains(&proc[opening_name_range]) {
@@ -70,7 +99,11 @@ pub fn process_tag(proc: &mut Processor) -> ProcessingResult<()> {
     };
 
     match tag_type {
-        TagType::Script => process_script(proc)?,
+        TagType::Script => if attr_type_value.is_none() || attr_type_value.filter(|n| JAVASCRIPT_MIME_TYPES.contains(&proc[*n])).is_some() {
+            process_js_script(proc)?;
+        } else {
+            process_text_script(proc)?;
+        },
         TagType::Style => process_style(proc)?,
         _ => process_content(proc, Some(opening_name_range))?,
     };