From adfbcb1f74f3ffce5eae03c7e263a4059b6fa0d4 Mon Sep 17 00:00:00 2001
From: Wilson Lin <code@wilsonl.in>
Date: Mon, 25 Dec 2023 10:28:04 +1100
Subject: [PATCH] Gate possibly noncompliant entity minifications under
 `allow_optimal_entities`

---
 CHANGELOG.md                                  |   1 +
 README.md                                     |   5 +-
 minhtml/src/main.rs                           |   5 +
 minify-html-common/src/tests/mod.rs           |   5 +-
 .../in/wilsonl/minifyhtml/Configuration.java  |   9 ++
 .../minifyhtml/Configuration.java.gen.js      |   2 +
 minify-html-java/src/main/rust/lib.rs         |   1 +
 minify-html-nodejs/index.d.ts                 |  34 +++---
 minify-html-nodejs/src/lib.rs                 |   1 +
 minify-html-python/minify_html.pyi            |   1 +
 minify-html-python/src/lib.rs                 |   3 +
 minify-html-ruby/ext/minify_html/src/lib.rs   |   1 +
 minify-html-wasm/src/lib.rs                   |   1 +
 minify-html/src/cfg/mod.rs                    |  10 +-
 minify-html/src/entity/encode.rs              |  18 ++-
 minify-html/src/minify/attr.rs                | 107 ++++++++++++++++--
 minify-html/src/minify/content.rs             |  21 +++-
 minify-html/src/minify/rcdata.rs              |  21 +++-
 18 files changed, 196 insertions(+), 50 deletions(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 1a566942..b5e859b7 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -8,6 +8,7 @@
   - `ensure_spec_compliant_unquoted_attribute_values` => `allow_noncompliant_unquoted_attribute_values`
   - `keep_spaces_between_attributes` => `allow_removing_spaces_between_attributes`
   - `Cfg::spec_compliant()` => `Cfg::enable_possibly_noncompliant(&mut self)`
+- BREAKING: Some entity minifications are now classified as "possibly noncompliant" and can be enabled via the `allow_optimal_entities` option but won't be performed by default.
 
 ## 0.15.0
 
diff --git a/README.md b/README.md
index b64b9bb0..0edc7f74 100644
--- a/README.md
+++ b/README.md
@@ -252,9 +252,12 @@ Note that in all of these syntax, the parsing is "dumb": it will simply look for
 
 ### Spec compliance
 
-To minify even further, it's possible to enable options that may output HTML that doesn't fully comply with the specs. This is almost 100% safe on all browsers, as browsers have consistent interpretation and rendering behaviour even for such HTML, which can be taken advantage of for better minification. Refer to these options:
+WHATWG is the current HTML standard and [obsoletes all previous standards](https://www.w3.org/html/). WHATWG lists suggested validators [here](https://whatwg.org/validator/).
+
+To minify even further, it's possible to enable options that may output HTML that doesn't fully pass validation, but is still interpreted and rendered correctly according to the [WHATWG parsing specification](https://html.spec.whatwg.org/multipage/parsing.html), which major browser engines (Firefox, Chrome, Safari) implement. Refer to these options:
 
 - `allow_noncompliant_unquoted_attribute_values`
+- `allow_optimal_entities`
 - `allow_removing_spaces_between_attributes`
 - `minify_doctype`
 
diff --git a/minhtml/src/main.rs b/minhtml/src/main.rs
index 8c49e290..72a607c4 100644
--- a/minhtml/src/main.rs
+++ b/minhtml/src/main.rs
@@ -30,6 +30,10 @@ struct Cli {
   #[structopt(long)]
   allow_noncompliant_unquoted_attribute_values: bool,
 
+  /// Allow some minifications around entities that may not pass validation, but will still be parsed correctly by almost all browsers.
+  #[structopt(long)]
+  allow_optimal_entities: bool,
+
   /// Allow removing_spaces between attributes when possible, which may not be spec compliant. These will still be parsed correctly by almost all browsers.
   #[structopt(long)]
   allow_removing_spaces_between_attributes: bool,
@@ -110,6 +114,7 @@ fn main() {
   #[rustfmt::skip]
   let cfg = Arc::new(Cfg {
     allow_noncompliant_unquoted_attribute_values: args.allow_noncompliant_unquoted_attribute_values,
+    allow_optimal_entities: args.allow_optimal_entities,
     allow_removing_spaces_between_attributes: args.allow_removing_spaces_between_attributes,
     keep_closing_tags: args.keep_closing_tags,
     keep_comments: args.keep_comments,
diff --git a/minify-html-common/src/tests/mod.rs b/minify-html-common/src/tests/mod.rs
index 3a762158..16a3970a 100644
--- a/minify-html-common/src/tests/mod.rs
+++ b/minify-html-common/src/tests/mod.rs
@@ -432,7 +432,10 @@ pub fn create_common_js_test_data() -> HashMap<&'static [u8], &'static [u8]> {
   let mut t = HashMap::<&'static [u8], &'static [u8]>::new();
 
   // intentionally malformed
-  t.insert(b"<script><script></script></script>", b"<script><script></script><script>");
+  t.insert(
+    b"<script><script></script></script>",
+    b"<script><script></script><script>",
+  );
 
   // js minification
   t.insert(b"<script></script>", b"<script></script>");
diff --git a/minify-html-java/src/main/java/in/wilsonl/minifyhtml/Configuration.java b/minify-html-java/src/main/java/in/wilsonl/minifyhtml/Configuration.java
index 1279c7cf..c06181da 100644
--- a/minify-html-java/src/main/java/in/wilsonl/minifyhtml/Configuration.java
+++ b/minify-html-java/src/main/java/in/wilsonl/minifyhtml/Configuration.java
@@ -7,6 +7,7 @@
  */
 public class Configuration {
   public final boolean allow_noncompliant_unquoted_attribute_values;
+  public final boolean allow_optimal_entities;
   public final boolean allow_removing_spaces_between_attributes;
   public final boolean keep_closing_tags;
   public final boolean keep_comments;
@@ -23,6 +24,7 @@ public class Configuration {
 
   private Configuration(
     boolean allow_noncompliant_unquoted_attribute_values,
+    boolean allow_optimal_entities,
     boolean allow_removing_spaces_between_attributes,
     boolean keep_closing_tags,
     boolean keep_comments,
@@ -38,6 +40,7 @@ private Configuration(
     boolean remove_processing_instructions
   ) {
     this.allow_noncompliant_unquoted_attribute_values = allow_noncompliant_unquoted_attribute_values;
+    this.allow_optimal_entities = allow_optimal_entities;
     this.allow_removing_spaces_between_attributes = allow_removing_spaces_between_attributes;
     this.keep_closing_tags = keep_closing_tags;
     this.keep_comments = keep_comments;
@@ -58,6 +61,7 @@ private Configuration(
    */
   public static class Builder {
     private boolean allow_noncompliant_unquoted_attribute_values = false;
+    private boolean allow_optimal_entities = false;
     private boolean allow_removing_spaces_between_attributes = false;
     private boolean keep_closing_tags = false;
     private boolean keep_comments = false;
@@ -76,6 +80,10 @@ public Builder setAllowNoncompliantUnquotedAttributeValues(boolean v) {
       this.allow_noncompliant_unquoted_attribute_values = v;
       return this;
     }
+    public Builder setAllowOptimalEntities(boolean v) {
+      this.allow_optimal_entities = v;
+      return this;
+    }
     public Builder setAllowRemovingSpacesBetweenAttributes(boolean v) {
       this.allow_removing_spaces_between_attributes = v;
       return this;
@@ -132,6 +140,7 @@ public Builder setRemoveProcessingInstructions(boolean v) {
     public Configuration build() {
       return new Configuration(
         this.allow_noncompliant_unquoted_attribute_values,
+        this.allow_optimal_entities,
         this.allow_removing_spaces_between_attributes,
         this.keep_closing_tags,
         this.keep_comments,
diff --git a/minify-html-java/src/main/java/in/wilsonl/minifyhtml/Configuration.java.gen.js b/minify-html-java/src/main/java/in/wilsonl/minifyhtml/Configuration.java.gen.js
index 6f7bb6d0..c76e5d04 100644
--- a/minify-html-java/src/main/java/in/wilsonl/minifyhtml/Configuration.java.gen.js
+++ b/minify-html-java/src/main/java/in/wilsonl/minifyhtml/Configuration.java.gen.js
@@ -16,6 +16,8 @@ for (const [_, snake] of cfgRs.matchAll(/^\s*pub ([a-zA-Z0-9_]+): bool,?\s*$/gm)
 const java = `
 package in.wilsonl.minifyhtml;
 
+// WARNING: Do not manually edit, use Configuration.java.gen.js.
+
 /**
  * Class representing minification configuration.
  */
diff --git a/minify-html-java/src/main/rust/lib.rs b/minify-html-java/src/main/rust/lib.rs
index e72a026d..ead6d2b0 100644
--- a/minify-html-java/src/main/rust/lib.rs
+++ b/minify-html-java/src/main/rust/lib.rs
@@ -12,6 +12,7 @@ fn build_cfg(env: &JNIEnv, obj: &JObject) -> Cfg {
   // This is a statement because "attributes on expressions are experimental".
   let cfg = Cfg {
     allow_noncompliant_unquoted_attribute_values: env.get_field(*obj, "allow_noncompliant_unquoted_attribute_values", "Z").unwrap().z().unwrap(),
+    allow_optimal_entities: env.get_field(*obj, "allow_optimal_entities", "Z").unwrap().z().unwrap(),
     allow_removing_spaces_between_attributes: env.get_field(*obj, "allow_removing_spaces_between_attributes", "Z").unwrap().z().unwrap(),
     keep_closing_tags: env.get_field(*obj, "keep_closing_tags", "Z").unwrap().z().unwrap(),
     keep_comments: env.get_field(*obj, "keep_comments", "Z").unwrap().z().unwrap(),
diff --git a/minify-html-nodejs/index.d.ts b/minify-html-nodejs/index.d.ts
index 7f0da0ed..8730db2b 100644
--- a/minify-html-nodejs/index.d.ts
+++ b/minify-html-nodejs/index.d.ts
@@ -8,35 +8,35 @@
 export function minify(
   src: Buffer,
   cfg: {
-    /** Do not minify DOCTYPEs. Minified DOCTYPEs may not be spec compliant. */
-    do_not_minify_doctype?: boolean;
-    /** Ensure all unquoted attribute values in the output do not contain any characters prohibited by the WHATWG specification. */
-    ensure_spec_compliant_unquoted_attribute_values?: boolean;
+    /** Allow unquoted attribute values in the output to contain characters prohibited by the [WHATWG specification](https://html.spec.whatwg.org/multipage/syntax.html#attributes-2). These will still be parsed correctly by almost all browsers. */
+    allow_noncompliant_unquoted_attribute_values?: boolean;
+    /** Allow some minifications around entities that may not pass validation, but will still be parsed correctly by almost all browsers. */
+    allow_optimal_entities?: boolean;
+    /** Allow removing_spaces between attributes when possible, which may not be spec compliant. These will still be parsed correctly by almost all browsers. */
+    allow_removing_spaces_between_attributes?: boolean;
     /** Do not omit closing tags when possible. */
     keep_closing_tags?: boolean;
-    /** Do not omit `<html>` and `<head>` opening tags when they don't have attributes. */
-    keep_html_and_head_opening_tags?: boolean;
-    /** Keep spaces between attributes when possible to conform to HTML standards. */
-    keep_spaces_between_attributes?: boolean;
     /** Keep all comments. */
     keep_comments?: boolean;
+    /** Do not omit `<html>` and `<head>` opening tags when they don't have attributes. */
+    keep_html_and_head_opening_tags?: boolean;
+    /** Keep `type=text` attribute name and value on `<input>` elements. */
+    keep_input_type_text_attr?: boolean;
     /** Keep SSI comments. */
     keep_ssi_comments?: boolean;
+    /** Minify CSS in `<style>` tags and `style` attributes using [https://github.com/parcel-bundler/lightningcss](lightningcss). */
+    minify_css?: boolean;
+    /** Minify DOCTYPEs. Minified DOCTYPEs may not be spec compliant, but will still be parsed correctly by almost all browsers. */
+    minify_doctype?: boolean;
+    /** Minify JavaScript in `<script>` tags using [minify-js](https://github.com/wilsonzlin/minify-js). */
+    minify_js?: boolean;
     /** When `{{`, `{#`, or `{%` are seen in content, all source code until the subsequent matching closing `}}`, `#}`, or `%}` respectively gets piped through untouched. */
     preserve_brace_template_syntax?: boolean;
     /** When `<%` is seen in content, all source code until the subsequent matching closing `%>` gets piped through untouched. */
     preserve_chevron_percent_template_syntax?: boolean;
-    /**
-     * If enabled, content in `<script>` tags with a JS or no [MIME type](https://mimesniff.spec.whatwg.org/#javascript-mime-type) will be minified using [minify-js](https://github.com/wilsonzlin/minify-js).
-     */
-    minify_js?: boolean;
-    /**
-     * If enabled, CSS in `<style>` tags and `style` attributes will be minified.
-     */
-    minify_css?: boolean;
     /** Remove all bangs. */
     remove_bangs?: boolean;
-    /** Remove all processing_instructions. */
+    /** Remove all processing instructions. */
     remove_processing_instructions?: boolean;
   }
 ): Buffer;
diff --git a/minify-html-nodejs/src/lib.rs b/minify-html-nodejs/src/lib.rs
index 38be9d22..2cd423b9 100644
--- a/minify-html-nodejs/src/lib.rs
+++ b/minify-html-nodejs/src/lib.rs
@@ -20,6 +20,7 @@ fn minify(mut cx: FunctionContext) -> JsResult<JsBuffer> {
   #[rustfmt::skip]
   let cfg = minify_html::Cfg {
     allow_noncompliant_unquoted_attribute_values: get_bool!(cx, opt, "allow_noncompliant_unquoted_attribute_values"),
+    allow_optimal_entities: get_bool!(cx, opt, "allow_optimal_entities"),
     allow_removing_spaces_between_attributes: get_bool!(cx, opt, "allow_removing_spaces_between_attributes"),
     keep_closing_tags: get_bool!(cx, opt, "keep_closing_tags"),
     keep_comments: get_bool!(cx, opt, "keep_comments"),
diff --git a/minify-html-python/minify_html.pyi b/minify-html-python/minify_html.pyi
index fef8b8a0..567f2f8b 100644
--- a/minify-html-python/minify_html.pyi
+++ b/minify-html-python/minify_html.pyi
@@ -1,6 +1,7 @@
 def minify(
     code: str,
     allow_noncompliant_unquoted_attribute_values: bool = False,
+    allow_optimal_entities: bool = False,
     allow_removing_spaces_between_attributes: bool = False,
     keep_closing_tags: bool = False,
     keep_comments: bool = False,
diff --git a/minify-html-python/src/lib.rs b/minify-html-python/src/lib.rs
index 215b7882..8742c617 100644
--- a/minify-html-python/src/lib.rs
+++ b/minify-html-python/src/lib.rs
@@ -8,6 +8,7 @@ use std::string::String;
 #[pyfunction(
   py_args = "*",
   allow_noncompliant_unquoted_attribute_values = "false",
+  allow_optimal_entities = "false",
   allow_removing_spaces_between_attributes = "false",
   keep_closing_tags = "false",
   keep_comments = "false",
@@ -25,6 +26,7 @@ use std::string::String;
 fn minify(
   code: String,
   allow_noncompliant_unquoted_attribute_values: bool,
+  allow_optimal_entities: bool,
   allow_removing_spaces_between_attributes: bool,
   keep_closing_tags: bool,
   keep_comments: bool,
@@ -42,6 +44,7 @@ fn minify(
   let code = code.into_bytes();
   let out_code = minify_html_native(&code, &Cfg {
     allow_noncompliant_unquoted_attribute_values,
+    allow_optimal_entities,
     allow_removing_spaces_between_attributes,
     keep_closing_tags,
     keep_comments,
diff --git a/minify-html-ruby/ext/minify_html/src/lib.rs b/minify-html-ruby/ext/minify_html/src/lib.rs
index 9f06ba5d..4e1c362a 100644
--- a/minify-html-ruby/ext/minify_html/src/lib.rs
+++ b/minify-html-ruby/ext/minify_html/src/lib.rs
@@ -9,6 +9,7 @@ fn minify_html(source: String, cfg: RHash) -> String {
   #[rustfmt::skip]
   let out_code = minify_html_native(source.as_bytes(), &CfgNative {
     allow_noncompliant_unquoted_attribute_values: cfg.aref(StaticSymbol::new("allow_noncompliant_unquoted_attribute_values")).unwrap_or_default(),
+    allow_optimal_entities: cfg.aref(StaticSymbol::new("allow_optimal_entities")).unwrap_or_default(),
     allow_removing_spaces_between_attributes: cfg.aref(StaticSymbol::new("allow_removing_spaces_between_attributes")).unwrap_or_default(),
     keep_closing_tags: cfg.aref(StaticSymbol::new("keep_closing_tags")).unwrap_or_default(),
     keep_comments: cfg.aref(StaticSymbol::new("keep_comments")).unwrap_or_default(),
diff --git a/minify-html-wasm/src/lib.rs b/minify-html-wasm/src/lib.rs
index e1832dc3..b83b96d8 100644
--- a/minify-html-wasm/src/lib.rs
+++ b/minify-html-wasm/src/lib.rs
@@ -23,6 +23,7 @@ pub fn minify(code: &[u8], cfg: &JsValue) -> Vec<u8> {
   #[rustfmt::skip]
   let cfg = minify_html::Cfg {
     allow_noncompliant_unquoted_attribute_values: get_prop!(cfg, "allow_noncompliant_unquoted_attribute_values"),
+    allow_optimal_entities: get_prop!(cfg, "allow_optimal_entities"),
     allow_removing_spaces_between_attributes: get_prop!(cfg, "allow_removing_spaces_between_attributes"),
     keep_closing_tags: get_prop!(cfg, "keep_closing_tags"),
     keep_comments: get_prop!(cfg, "keep_comments"),
diff --git a/minify-html/src/cfg/mod.rs b/minify-html/src/cfg/mod.rs
index 4f741e11..1fd63be7 100644
--- a/minify-html/src/cfg/mod.rs
+++ b/minify-html/src/cfg/mod.rs
@@ -4,6 +4,8 @@
 pub struct Cfg {
   /// Allow unquoted attribute values in the output to contain characters prohibited by the [WHATWG specification](https://html.spec.whatwg.org/multipage/syntax.html#attributes-2). These will still be parsed correctly by almost all browsers.
   pub allow_noncompliant_unquoted_attribute_values: bool,
+  /// Allow some minifications around entities that may not pass validation, but will still be parsed correctly by almost all browsers.
+  pub allow_optimal_entities: bool,
   /// Allow removing_spaces between attributes when possible, which may not be spec compliant. These will still be parsed correctly by almost all browsers.
   pub allow_removing_spaces_between_attributes: bool,
   /// Do not omit closing tags when possible.
@@ -20,12 +22,7 @@ pub struct Cfg {
   pub minify_css: bool,
   /// Minify DOCTYPEs. Minified DOCTYPEs may not be spec compliant, but will still be parsed correctly by almost all browsers.
   pub minify_doctype: bool,
-  /// Minify JavaScript in `<script>` tags using
-  /// [minify-js](https://github.com/wilsonzlin/minify-js).
-  ///
-  /// Only `<script>` tags with a valid or no
-  /// [MIME type](https://mimesniff.spec.whatwg.org/#javascript-mime-type) is considered to
-  /// contain JavaScript, as per the specification.
+  /// Minify JavaScript in `<script>` tags using [minify-js](https://github.com/wilsonzlin/minify-js).
   pub minify_js: bool,
   /// When `{{`, `{#`, or `{%` are seen in content, all source code until the subsequent matching closing `}}`, `#}`, or `%}` respectively gets piped through untouched.
   pub preserve_brace_template_syntax: bool,
@@ -44,6 +41,7 @@ impl Cfg {
 
   pub fn enable_possibly_noncompliant(&mut self) {
     self.allow_noncompliant_unquoted_attribute_values = true;
+    self.allow_optimal_entities = true;
     self.allow_removing_spaces_between_attributes = true;
     self.minify_doctype = true;
   }
diff --git a/minify-html/src/entity/encode.rs b/minify-html/src/entity/encode.rs
index c6e11646..57ccadc6 100644
--- a/minify-html/src/entity/encode.rs
+++ b/minify-html/src/entity/encode.rs
@@ -19,7 +19,12 @@ lazy_static! {
 
 // Encodes ampersands when necessary, as well as UTF-8 sequences that are shorter encoded.
 // Does not handle context-specific escaping e.g. `>`, `'`, `"`.
-pub fn encode_entities(mut code: &[u8], in_attr_val: bool) -> Vec<u8> {
+// Set {@param must_end_with_semicolon} to true to pass validation.
+pub fn encode_entities(
+  mut code: &[u8],
+  in_attr_val: bool,
+  must_end_with_semicolon: bool,
+) -> Vec<u8> {
   let mut res = Vec::<u8>::new();
   while !code.is_empty() {
     let (before, matched) = match memchr(b'&', code) {
@@ -37,17 +42,18 @@ pub fn encode_entities(mut code: &[u8], in_attr_val: bool) -> Vec<u8> {
             EntityType::Named(_)
               if in_attr_val
                 && code[len - 1] != b';'
-                && code
-                  .get(len)
-                  .filter(|&&c| ALPHANUMERIC_OR_EQUALS[c])
-                  .is_some() =>
+                && code.get(len).is_some_and(|&c| ALPHANUMERIC_OR_EQUALS[c]) =>
             {
               // A named entity inside an attribute value that doesn't end with semicolon but is followed by an alphanumeric or `=` character is not decoded, so we don't need to encode.
               // https://html.spec.whatwg.org/multipage/parsing.html#named-character-reference-state.
               0
             }
             _ => {
-              res.extend_from_slice(b"&amp");
+              if must_end_with_semicolon {
+                res.extend_from_slice(b"&amp;");
+              } else {
+                res.extend_from_slice(b"&amp");
+              };
               // Skip the leading ampersand, as it will be replaced by `&amp`.
               1
             }
diff --git a/minify-html/src/minify/attr.rs b/minify-html/src/minify/attr.rs
index f3935bdc..89769127 100644
--- a/minify-html/src/minify/attr.rs
+++ b/minify-html/src/minify/attr.rs
@@ -40,6 +40,13 @@ fn build_double_quoted_replacer() -> Replacer {
   )
 }
 
+// To pass validation, entities MUST end with a semicolon.
+fn build_whatwg_double_quoted_replacer() -> Replacer {
+  Replacer::new(AhoCorasickBuilder::new().dfa(true).build([b"\""]), vec![
+    b"&#34;".to_vec(),
+  ])
+}
+
 fn build_single_quoted_replacer() -> Replacer {
   let mut patterns = Vec::<Vec<u8>>::new();
   let mut replacements = Vec::<Vec<u8>>::new();
@@ -62,6 +69,13 @@ fn build_single_quoted_replacer() -> Replacer {
   )
 }
 
+// To pass validation, entities MUST end with a semicolon.
+fn build_whatwg_single_quoted_replacer() -> Replacer {
+  Replacer::new(AhoCorasickBuilder::new().dfa(true).build([b"'"]), vec![
+    b"&#39;".to_vec(),
+  ])
+}
+
 // TODO Sync with WHITESPACE definition.
 static WS: &[(u8, &[u8])] = &[
   (b'\x09', b"&#9"),
@@ -119,7 +133,8 @@ static WHATWG_UNQUOTED: &[(u8, &[u8])] = &[
   (b'`', b"&#6"),
 ];
 
-fn build_whatwg_unquoted_replacer() -> Replacer {
+// This encodes more characters in the value but may not end those entities with semicolons.
+fn build_semi_whatwg_unquoted_replacer() -> Replacer {
   let mut patterns = Vec::<Vec<u8>>::new();
   let mut replacements = Vec::<Vec<u8>>::new();
 
@@ -184,10 +199,55 @@ fn build_whatwg_unquoted_replacer() -> Replacer {
   )
 }
 
+// To pass validation, entities MUST end with a semicolon.
+fn build_whatwg_unquoted_replacer() -> Replacer {
+  let mut patterns = Vec::<Vec<u8>>::new();
+  let mut replacements = Vec::<Vec<u8>>::new();
+
+  // Replace all whitespace with a numeric entity.
+  for &(ws, rep) in WS {
+    patterns.push(vec![ws]);
+    replacements.push({
+      let mut ent = rep.to_vec();
+      ent.push(b';');
+      ent
+    });
+  }
+
+  // Replace WHATWG-disallowed characters with a numeric entity
+  for &(ws, rep) in WHATWG_UNQUOTED {
+    patterns.push(vec![ws]);
+    replacements.push({
+      let mut ent = rep.to_vec();
+      ent.push(b';');
+      ent
+    });
+  }
+
+  // Replace all `<` with `&lt;`.
+  patterns.push(b"<".to_vec());
+  replacements.push(b"&lt;".to_vec());
+
+  // Replace all `>` with `&gt;`.
+  patterns.push(b">".to_vec());
+  replacements.push(b"&gt;".to_vec());
+
+  Replacer::new(
+    AhoCorasickBuilder::new()
+      .dfa(true)
+      .match_kind(MatchKind::LeftmostLongest)
+      .build(patterns),
+    replacements,
+  )
+}
+
 lazy_static! {
   static ref DOUBLE_QUOTED_REPLACER: Replacer = build_double_quoted_replacer();
   static ref SINGLE_QUOTED_REPLACER: Replacer = build_single_quoted_replacer();
   static ref UNQUOTED_REPLACER: Replacer = build_unquoted_replacer();
+  static ref SEMI_WHATWG_UNQUOTED_REPLACER: Replacer = build_semi_whatwg_unquoted_replacer();
+  static ref WHATWG_DOUBLE_QUOTED_REPLACER: Replacer = build_whatwg_double_quoted_replacer();
+  static ref WHATWG_SINGLE_QUOTED_REPLACER: Replacer = build_whatwg_single_quoted_replacer();
   static ref WHATWG_UNQUOTED_REPLACER: Replacer = build_whatwg_unquoted_replacer();
 }
 
@@ -222,28 +282,40 @@ impl AttrMinifiedValue {
   }
 }
 
-pub fn encode_using_double_quotes(val: &[u8]) -> AttrMinifiedValue {
+pub fn encode_using_double_quotes(val: &[u8], must_end_with_semicolon: bool) -> AttrMinifiedValue {
   AttrMinifiedValue {
     quoted: true,
     prefix: b"\"",
-    data: DOUBLE_QUOTED_REPLACER.replace_all(val),
+    data: if must_end_with_semicolon {
+      WHATWG_DOUBLE_QUOTED_REPLACER.replace_all(val)
+    } else {
+      DOUBLE_QUOTED_REPLACER.replace_all(val)
+    },
     start: 0,
     suffix: b"\"",
   }
 }
 
-pub fn encode_using_single_quotes(val: &[u8]) -> AttrMinifiedValue {
+pub fn encode_using_single_quotes(val: &[u8], must_end_with_semicolon: bool) -> AttrMinifiedValue {
   AttrMinifiedValue {
     quoted: true,
     prefix: b"'",
-    data: SINGLE_QUOTED_REPLACER.replace_all(val),
+    data: if must_end_with_semicolon {
+      WHATWG_SINGLE_QUOTED_REPLACER.replace_all(val)
+    } else {
+      SINGLE_QUOTED_REPLACER.replace_all(val)
+    },
     start: 0,
     suffix: b"'",
   }
 }
 
-pub fn encode_unquoted(val: &[u8], whatwg: bool) -> AttrMinifiedValue {
-  if whatwg {
+pub fn encode_unquoted(
+  val: &[u8],
+  must_end_with_semicolon: bool,
+  no_illegal_chars: bool,
+) -> AttrMinifiedValue {
+  if must_end_with_semicolon {
     AttrMinifiedValue {
       quoted: false,
       prefix: b"",
@@ -251,6 +323,14 @@ pub fn encode_unquoted(val: &[u8], whatwg: bool) -> AttrMinifiedValue {
       start: 0,
       suffix: b"",
     }
+  } else if no_illegal_chars {
+    AttrMinifiedValue {
+      quoted: false,
+      prefix: b"",
+      data: SEMI_WHATWG_UNQUOTED_REPLACER.replace_all(val),
+      start: 0,
+      suffix: b"",
+    }
   } else {
     let data = UNQUOTED_REPLACER.replace_all(val);
     let prefix: &'static [u8] = match data.first() {
@@ -360,15 +440,20 @@ pub fn minify_attr(
     return AttrMinified::NoValue;
   };
 
-  let encoded = encode_entities(&value_raw, true);
+  let must_end_with_semicolon = !cfg.allow_optimal_entities;
+  let encoded = encode_entities(&value_raw, true, must_end_with_semicolon);
 
   // When lengths are equal, prefer double quotes to all and single quotes to unquoted.
-  let mut min = encode_using_double_quotes(&encoded);
-  let sq = encode_using_single_quotes(&encoded);
+  let mut min = encode_using_double_quotes(&encoded, must_end_with_semicolon);
+  let sq = encode_using_single_quotes(&encoded, must_end_with_semicolon);
   if sq.len() < min.len() {
     min = sq;
   };
-  let uq = encode_unquoted(&encoded, !cfg.allow_noncompliant_unquoted_attribute_values);
+  let uq = encode_unquoted(
+    &encoded,
+    must_end_with_semicolon,
+    !cfg.allow_noncompliant_unquoted_attribute_values,
+  );
   if uq.len() < min.len() {
     min = uq;
   };
diff --git a/minify-html/src/minify/content.rs b/minify-html/src/minify/content.rs
index bab65265..98d8df1f 100644
--- a/minify-html/src/minify/content.rs
+++ b/minify-html/src/minify/content.rs
@@ -23,7 +23,7 @@ use minify_html_common::whitespace::is_all_whitespace;
 use minify_html_common::whitespace::left_trim;
 use minify_html_common::whitespace::right_trim;
 
-fn build_chevron_replacer() -> Replacer {
+fn build_optimal_chevron_replacer() -> Replacer {
   let mut patterns = Vec::<Vec<u8>>::new();
   let mut replacements = Vec::<Vec<u8>>::new();
 
@@ -45,8 +45,15 @@ fn build_chevron_replacer() -> Replacer {
   )
 }
 
+fn build_whatwg_chevron_replacer() -> Replacer {
+  Replacer::new(AhoCorasickBuilder::new().dfa(true).build(["<"]), vec![
+    "&lt;".into(),
+  ])
+}
+
 lazy_static! {
-  static ref CHEVRON_REPLACER: Replacer = build_chevron_replacer();
+  static ref OPTIMAL_CHEVRON_REPLACER: Replacer = build_optimal_chevron_replacer();
+  static ref WHATWG_CHEVRON_REPLACER: Replacer = build_whatwg_chevron_replacer();
 }
 
 pub fn minify_content(
@@ -144,7 +151,7 @@ pub fn minify_content(
         children,
       ),
       NodeData::Instruction { code, ended } => minify_instruction(cfg, out, &code, ended),
-      NodeData::RcdataContent { typ, text } => minify_rcdata(out, typ, &text),
+      NodeData::RcdataContent { typ, text } => minify_rcdata(cfg, out, typ, &text),
       NodeData::ScriptOrStyleContent { code, lang } => match lang {
         ScriptOrStyleLang::CSS => minify_css(cfg, out, &code),
         ScriptOrStyleLang::Data => out.extend_from_slice(&code),
@@ -152,7 +159,13 @@ pub fn minify_content(
         ScriptOrStyleLang::JSModule => minify_js(cfg, minify_js::TopLevelMode::Module, out, &code),
       },
       NodeData::Text { value } => {
-        out.extend_from_slice(&CHEVRON_REPLACER.replace_all(&encode_entities(&value, false)))
+        let min = encode_entities(&value, false, !cfg.allow_optimal_entities);
+        let min = if cfg.allow_optimal_entities {
+          OPTIMAL_CHEVRON_REPLACER.replace_all(&min)
+        } else {
+          WHATWG_CHEVRON_REPLACER.replace_all(&min)
+        };
+        out.extend_from_slice(&min);
       }
       NodeData::Opaque { raw_source } => out.extend_from_slice(&raw_source),
     };
diff --git a/minify-html/src/minify/rcdata.rs b/minify-html/src/minify/rcdata.rs
index d1516d3c..fc1cdfc3 100644
--- a/minify-html/src/minify/rcdata.rs
+++ b/minify-html/src/minify/rcdata.rs
@@ -2,10 +2,11 @@ use crate::ast::RcdataContentType;
 use crate::entity::encode::encode_entities;
 use crate::tag::TAG_TEXTAREA_END;
 use crate::tag::TAG_TITLE_END;
+use crate::Cfg;
 
-pub fn minify_rcdata(out: &mut Vec<u8>, typ: RcdataContentType, text: &[u8]) {
+pub fn minify_rcdata(cfg: &Cfg, out: &mut Vec<u8>, typ: RcdataContentType, text: &[u8]) {
   // Encode entities, since they're still decoded by the browser.
-  let html = encode_entities(text, false);
+  let html = encode_entities(text, false, !cfg.allow_optimal_entities);
 
   // Since the text has been decoded, there may be unintentional matches to end tags that we must escape.
   let html = match typ {
@@ -13,8 +14,20 @@ pub fn minify_rcdata(out: &mut Vec<u8>, typ: RcdataContentType, text: &[u8]) {
     RcdataContentType::Title => &*TAG_TITLE_END,
   }
   .replace_all_bytes(&html, &[match typ {
-    RcdataContentType::Textarea => b"&LT/textarea".as_slice(),
-    RcdataContentType::Title => b"&LT/title".as_slice(),
+    RcdataContentType::Textarea => {
+      if cfg.allow_optimal_entities {
+        b"&LT/textarea".as_slice()
+      } else {
+        b"&lt;/textarea".as_slice()
+      }
+    }
+    RcdataContentType::Title => {
+      if cfg.allow_optimal_entities {
+        b"&LT/title".as_slice()
+      } else {
+        b"&lt;/title".as_slice()
+      }
+    }
   }]);
 
   out.extend_from_slice(&html);