├── .github
    ├── dependabot.yml
    └── workflows
    │   ├── ci-version.yml
    │   └── ci.yml
├── src
    ├── functions.rs
    ├── html_writer.rs
    ├── errors.rs
    ├── lib.rs
    └── html_minifier_helper.rs
├── Cargo.toml
├── LICENSE
├── rustfmt.toml
├── tests
    ├── data
    │   ├── index.min.html
    │   └── w3schools.com_tryhow_css_example_website.htm
    ├── mix.rs
    └── steps.rs
├── .gitignore
└── README.md


/.github/dependabot.yml:
--------------------------------------------------------------------------------
1 | version: 2
2 | updates:
3 |   - package-ecosystem: github-actions
4 |     directory: "/"
5 |     schedule:
6 |       interval: "weekly"


--------------------------------------------------------------------------------
/src/functions.rs:
--------------------------------------------------------------------------------
 1 | use std::{
 2 |     fmt::{self, Formatter},
 3 |     str::from_utf8_unchecked,
 4 | };
 5 | 
 6 | #[inline]
 7 | pub(crate) fn str_bytes_fmt(v: &[u8], f: &mut Formatter) -> Result<(), fmt::Error> {
 8 |     f.write_fmt(format_args!("{:?}", unsafe { from_utf8_unchecked(v) }))
 9 | }
10 | 
11 | #[inline]
12 | pub(crate) const fn is_whitespace(e: u8) -> bool {
13 |     matches!(e, 0x09..=0x0D | 0x1C..=0x20)
14 | }
15 | 
16 | #[inline]
17 | pub(crate) const fn is_ascii_control(e: u8) -> bool {
18 |     matches!(e, 0..=8 | 11..=31 | 127)
19 | }
20 | 


--------------------------------------------------------------------------------
/src/html_writer.rs:
--------------------------------------------------------------------------------
 1 | use std::io::Write;
 2 | 
 3 | use crate::HTMLMinifierError;
 4 | 
 5 | /// Implement this trait to build a HTML writer.
 6 | pub trait HTMLWriter {
 7 |     fn push(&mut self, e: u8) -> Result<(), HTMLMinifierError>;
 8 |     fn push_bytes(&mut self, bytes: &[u8]) -> Result<(), HTMLMinifierError>;
 9 | }
10 | 
11 | impl<W: Write> HTMLWriter for W {
12 |     #[inline]
13 |     fn push(&mut self, e: u8) -> Result<(), HTMLMinifierError> {
14 |         Ok(self.write_all(&[e])?)
15 |     }
16 | 
17 |     #[inline]
18 |     fn push_bytes(&mut self, bytes: &[u8]) -> Result<(), HTMLMinifierError> {
19 |         Ok(self.write_all(bytes)?)
20 |     }
21 | }
22 | 


--------------------------------------------------------------------------------
/src/errors.rs:
--------------------------------------------------------------------------------
 1 | use std::{
 2 |     error::Error,
 3 |     fmt::{self, Display, Formatter},
 4 |     io,
 5 | };
 6 | 
 7 | /// Errors for `HTMLMinifier`.
 8 | #[derive(Debug)]
 9 | pub enum HTMLMinifierError {
10 |     CSSError(&'static str),
11 |     IOError(io::Error),
12 | }
13 | 
14 | impl From<io::Error> for HTMLMinifierError {
15 |     #[inline]
16 |     fn from(error: io::Error) -> Self {
17 |         HTMLMinifierError::IOError(error)
18 |     }
19 | }
20 | 
21 | impl Display for HTMLMinifierError {
22 |     #[inline]
23 |     fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), fmt::Error> {
24 |         match self {
25 |             HTMLMinifierError::CSSError(error) => Display::fmt(error, f),
26 |             HTMLMinifierError::IOError(error) => Display::fmt(error, f),
27 |         }
28 |     }
29 | }
30 | 
31 | impl Error for HTMLMinifierError {}
32 | 


--------------------------------------------------------------------------------
/Cargo.toml:
--------------------------------------------------------------------------------
 1 | [package]
 2 | name = "html-minifier"
 3 | version = "5.0.0"
 4 | authors = ["Magic Len <len@magiclen.org>"]
 5 | edition = "2021"
 6 | rust-version = "1.60"
 7 | repository = "https://github.com/magiclen/html-minifier"
 8 | homepage = "https://magiclen.org/html-minifier"
 9 | keywords = ["html", "minify", "sctipt", "style"]
10 | categories = ["encoding"]
11 | description = "This library can help you generate and minify your HTML code at the same time. It also supports to minify JS and CSS in `<style>`, `<script>` elements, and ignores the minification of `<pre>`, `<code>` and `<textarea>` elements."
12 | license = "MIT"
13 | include = ["src/**/*", "Cargo.toml", "README.md", "LICENSE"]
14 | 
15 | [dependencies]
16 | html-escape = "0.2"
17 | cow-utils = "0.1"
18 | minifier = "0.3"
19 | 
20 | [dependencies.educe]
21 | version = ">=0.4"
22 | features = ["Debug", "Default"]
23 | default-features = false


--------------------------------------------------------------------------------
/LICENSE:
--------------------------------------------------------------------------------
 1 | MIT License
 2 | 
 3 | Copyright (c) 2018 magiclen.org (Ron Li)
 4 | 
 5 | Permission is hereby granted, free of charge, to any person obtaining a copy
 6 | of this software and associated documentation files (the "Software"), to deal
 7 | in the Software without restriction, including without limitation the rights
 8 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 9 | copies of the Software, and to permit persons to whom the Software is
10 | furnished to do so, subject to the following conditions:
11 | 
12 | The above copyright notice and this permission notice shall be included in all
13 | copies or substantial portions of the Software.
14 | 
15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
17 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
18 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
19 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
20 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
21 | SOFTWARE.
22 | 


--------------------------------------------------------------------------------
/.github/workflows/ci-version.yml:
--------------------------------------------------------------------------------
 1 | name: CI-version
 2 | 
 3 | on:
 4 |   push:
 5 |     tags:
 6 |       - "v*"
 7 | 
 8 | env:
 9 |   CARGO_TERM_COLOR: always
10 | 
11 | jobs:
12 |   tests:
13 |     strategy:
14 |       fail-fast: false
15 |       matrix:
16 |         os:
17 |           - ubuntu-latest
18 |           - macos-latest
19 |           - windows-latest
20 |         toolchain:
21 |           - stable
22 |           - nightly
23 |         features:
24 |           -
25 |           - --no-default-features
26 |     name: Test ${{ matrix.toolchain }} on ${{ matrix.os }} (${{ matrix.features }})
27 |     runs-on: ${{ matrix.os }}
28 |     steps:
29 |       - uses: actions/checkout@v4
30 |       - uses: actions-rust-lang/setup-rust-toolchain@v1
31 |         with:
32 |           toolchain: ${{ matrix.toolchain }}
33 |       - run: cargo test --release ${{ matrix.features }}
34 |       - run: cargo doc --release ${{ matrix.features }}
35 | 
36 |   MSRV:
37 |     strategy:
38 |       fail-fast: false
39 |       matrix:
40 |         os:
41 |           - ubuntu-latest
42 |           - macos-latest
43 |           - windows-latest
44 |         toolchain:
45 |           - "1.60"
46 |         features:
47 |           -
48 |           - --no-default-features
49 |     name: Test ${{ matrix.toolchain }} on ${{ matrix.os }} (${{ matrix.features }})
50 |     runs-on: ${{ matrix.os }}
51 |     steps:
52 |       - uses: actions/checkout@v4
53 |       - uses: actions-rust-lang/setup-rust-toolchain@v1
54 |         with:
55 |           toolchain: ${{ matrix.toolchain }}
56 |       - run: cargo test --release --lib --bins ${{ matrix.features }}


--------------------------------------------------------------------------------
/rustfmt.toml:
--------------------------------------------------------------------------------
 1 | # array_width = 60
 2 | # attr_fn_like_width = 70
 3 | binop_separator = "Front"
 4 | blank_lines_lower_bound = 0
 5 | blank_lines_upper_bound = 1
 6 | brace_style = "PreferSameLine"
 7 | # chain_width = 60
 8 | color = "Auto"
 9 | # comment_width = 100
10 | condense_wildcard_suffixes = true
11 | control_brace_style = "AlwaysSameLine"
12 | empty_item_single_line = true
13 | enum_discrim_align_threshold = 80
14 | error_on_line_overflow = false
15 | error_on_unformatted = false
16 | # fn_call_width = 60
17 | fn_params_layout = "Tall"
18 | fn_single_line = false
19 | force_explicit_abi = true
20 | force_multiline_blocks = false
21 | format_code_in_doc_comments = true
22 | doc_comment_code_block_width = 80
23 | format_generated_files = true
24 | format_macro_matchers = true
25 | format_macro_bodies = true
26 | skip_macro_invocations = []
27 | format_strings = true
28 | hard_tabs = false
29 | hex_literal_case = "Upper"
30 | imports_indent = "Block"
31 | imports_layout = "Mixed"
32 | indent_style = "Block"
33 | inline_attribute_width = 0
34 | match_arm_blocks = true
35 | match_arm_leading_pipes = "Never"
36 | match_block_trailing_comma = true
37 | max_width = 100
38 | merge_derives = true
39 | imports_granularity = "Crate"
40 | newline_style = "Unix"
41 | normalize_comments = false
42 | normalize_doc_attributes = true
43 | overflow_delimited_expr = true
44 | remove_nested_parens = true
45 | reorder_impl_items = true
46 | reorder_imports = true
47 | group_imports = "StdExternalCrate"
48 | reorder_modules = true
49 | short_array_element_width_threshold = 10
50 | # single_line_if_else_max_width = 50
51 | space_after_colon = true
52 | space_before_colon = false
53 | spaces_around_ranges = false
54 | struct_field_align_threshold = 80
55 | struct_lit_single_line = false
56 | # struct_lit_width = 18
57 | # struct_variant_width = 35
58 | tab_spaces = 4
59 | trailing_comma = "Vertical"
60 | trailing_semicolon = true
61 | type_punctuation_density = "Wide"
62 | use_field_init_shorthand = true
63 | use_small_heuristics = "Max"
64 | use_try_shorthand = true
65 | where_single_line = false
66 | wrap_comments = false


--------------------------------------------------------------------------------
/.github/workflows/ci.yml:
--------------------------------------------------------------------------------
 1 | name: CI
 2 | 
 3 | on: [ push, pull_request ]
 4 | 
 5 | env:
 6 |   CARGO_TERM_COLOR: always
 7 | 
 8 | jobs:
 9 |   rustfmt:
10 |     runs-on: ubuntu-latest
11 |     steps:
12 |       - uses: actions/checkout@v4
13 |       - uses: actions-rust-lang/setup-rust-toolchain@v1
14 |         with:
15 |           toolchain: nightly
16 |           components: rustfmt
17 |       - uses: actions-rust-lang/rustfmt@v1
18 | 
19 |   clippy:
20 |     runs-on: ubuntu-latest
21 |     steps:
22 |       - uses: actions/checkout@v4
23 |       - uses: actions-rust-lang/setup-rust-toolchain@v1
24 |         with:
25 |           components: clippy
26 |       - run: cargo clippy --all-targets --all-features -- -D warnings
27 | 
28 |   tests:
29 |     strategy:
30 |       fail-fast: false
31 |       matrix:
32 |         os:
33 |           - ubuntu-latest
34 |           - macos-latest
35 |           - windows-latest
36 |         toolchain:
37 |           - stable
38 |           - nightly
39 |         features:
40 |           -
41 |           - --no-default-features
42 |     name: Test ${{ matrix.toolchain }} on ${{ matrix.os }} (${{ matrix.features }})
43 |     runs-on: ${{ matrix.os }}
44 |     steps:
45 |       - uses: actions/checkout@v4
46 |       - uses: actions-rust-lang/setup-rust-toolchain@v1
47 |         with:
48 |           toolchain: ${{ matrix.toolchain }}
49 |       - run: cargo test ${{ matrix.features }}
50 |       - run: cargo doc ${{ matrix.features }}
51 | 
52 |   MSRV:
53 |     strategy:
54 |       fail-fast: false
55 |       matrix:
56 |         os:
57 |           - ubuntu-latest
58 |           - macos-latest
59 |           - windows-latest
60 |         toolchain:
61 |           - "1.60"
62 |         features:
63 |           -
64 |           - --no-default-features
65 |     name: Test ${{ matrix.toolchain }} on ${{ matrix.os }} (${{ matrix.features }})
66 |     runs-on: ${{ matrix.os }}
67 |     steps:
68 |       - uses: actions/checkout@v4
69 |       - uses: actions-rust-lang/setup-rust-toolchain@v1
70 |         with:
71 |           toolchain: ${{ matrix.toolchain }}
72 |       - run: cargo test --lib --bins ${{ matrix.features }}


--------------------------------------------------------------------------------
/tests/data/index.min.html:
--------------------------------------------------------------------------------
 1 | <!DOCTYPE html>
 2 | <html lang="en">
 3 | <head>
 4 | <title>Page Title</title>
 5 | <meta charset="UTF-8">
 6 | <meta name="viewport" content="width=device-width, initial-scale=1">
 7 | <style>*{box-sizing:border-box;}body{font-family:Arial,Helvetica,sans-serif;margin:0;}.header{padding:80px;text-align:center;background:#1abc9c;color:white;}.header h1{font-size:40px;}.navbar{overflow:hidden;background-color:#333;position:sticky;position:-webkit-sticky;top:0;}.navbar a{float:left;display:block;color:white;text-align:center;padding:14px 20px;text-decoration:none;}.navbar a.right{float:right;}.navbar a:hover{background-color:#ddd;color:black;}.navbar a.active{background-color:#666;color:white;}.row{display:-ms-flexbox;display:flex;-ms-flex-wrap:wrap;flex-wrap:wrap;}.side{-ms-flex:30%;flex:30%;background-color:#f1f1f1;padding:20px;}.main{-ms-flex:70%;flex:70%;background-color:white;padding:20px;}.fakeimg{background-color:#aaa;width:100%;padding:20px;}.footer{padding:20px;text-align:center;background:#ddd;}@media screen and (max-width:700px){.row{flex-direction:column;}}@media screen and (max-width:400px){.navbar a{float:none;width:100%;}}</style>
 8 | </head>
 9 | <body>
10 | <div class="header">
11 | <h1>My Website</h1>
12 | <p>A <b>responsive</b> website created by me.</p>
13 | </div>
14 | <div class="navbar">
15 | <a href="#" class="active">Home</a>
16 | <a href="#">Link</a>
17 | <a href="#">Link</a>
18 | <a href="#" class="right">Link</a>
19 | </div>
20 | <div class="row">
21 | <div class="side">
22 | <h2>About Me</h2>
23 | <h5>Photo of me:</h5>
24 | <div class="fakeimg" style="height:200px;">Image</div>
25 | <p>Some text about me in culpa qui officia deserunt mollit anim..</p>
26 | <h3>More Text</h3>
27 | <p>Lorem ipsum dolor sit ame.</p>
28 | <div class="fakeimg" style="height:60px;">Image</div>
29 | <br>
30 | <div class="fakeimg" style="height:60px;">Image</div>
31 | <br>
32 | <div class="fakeimg" style="height:60px;">Image</div>
33 | </div>
34 | <div class="main">
35 | <h2>TITLE HEADING</h2>
36 | <h5>Title description, Dec 7, 2017</h5>
37 | <div class="fakeimg" style="height:200px;">Image</div>
38 | <p>Some text..</p>
39 | <p>Sunt in culpa qui officia deserunt mollit anim id est laborum consectetur adipiscing elit, sed do eiusmod
40 | tempor incididunt ut labore et dolore magna aliqua. Ut enim ad minim veniam, quis nostrud exercitation
41 | ullamco.</p>
42 | <br>
43 | <h2>TITLE HEADING</h2>
44 | <h5>Title description, Sep 2, 2017</h5>
45 | <div class="fakeimg" style="height:200px;">Image</div>
46 | <p>Some text..</p>
47 | <p>Sunt in culpa qui officia deserunt mollit anim id est laborum consectetur adipiscing elit, sed do eiusmod
48 | tempor incididunt ut labore et dolore magna aliqua. Ut enim ad minim veniam, quis nostrud exercitation
49 | ullamco.</p>
50 | </div>
51 | </div>
52 | <div class="footer">
53 | <h2>Footer</h2>
54 | </div>
55 | </body>
56 | </html>


--------------------------------------------------------------------------------
/.gitignore:
--------------------------------------------------------------------------------
  1 | ### Intellij+all ###
  2 | # Covers JetBrains IDEs: IntelliJ, RubyMine, PhpStorm, AppCode, PyCharm, CLion, Android Studio, WebStorm and Rider
  3 | # Reference: https://intellij-support.jetbrains.com/hc/en-us/articles/206544839
  4 | 
  5 | # User-specific stuff
  6 | .idea/**/workspace.xml
  7 | .idea/**/tasks.xml
  8 | .idea/**/usage.statistics.xml
  9 | .idea/**/dictionaries
 10 | .idea/**/shelf
 11 | 
 12 | # AWS User-specific
 13 | .idea/**/aws.xml
 14 | 
 15 | # Generated files
 16 | .idea/**/contentModel.xml
 17 | 
 18 | # Sensitive or high-churn files
 19 | .idea/**/dataSources/
 20 | .idea/**/dataSources.ids
 21 | .idea/**/dataSources.local.xml
 22 | .idea/**/sqlDataSources.xml
 23 | .idea/**/dynamic.xml
 24 | .idea/**/uiDesigner.xml
 25 | .idea/**/dbnavigator.xml
 26 | 
 27 | # Gradle
 28 | .idea/**/gradle.xml
 29 | .idea/**/libraries
 30 | 
 31 | # Gradle and Maven with auto-import
 32 | # When using Gradle or Maven with auto-import, you should exclude module files,
 33 | # since they will be recreated, and may cause churn.  Uncomment if using
 34 | # auto-import.
 35 | # .idea/artifacts
 36 | # .idea/compiler.xml
 37 | # .idea/jarRepositories.xml
 38 | # .idea/modules.xml
 39 | # .idea/*.iml
 40 | # .idea/modules
 41 | # *.iml
 42 | # *.ipr
 43 | 
 44 | # CMake
 45 | cmake-build-*/
 46 | 
 47 | # Mongo Explorer plugin
 48 | .idea/**/mongoSettings.xml
 49 | 
 50 | # File-based project format
 51 | *.iws
 52 | 
 53 | # IntelliJ
 54 | out/
 55 | 
 56 | # mpeltonen/sbt-idea plugin
 57 | .idea_modules/
 58 | 
 59 | # JIRA plugin
 60 | atlassian-ide-plugin.xml
 61 | 
 62 | # Cursive Clojure plugin
 63 | .idea/replstate.xml
 64 | 
 65 | # SonarLint plugin
 66 | .idea/sonarlint/
 67 | 
 68 | # Crashlytics plugin (for Android Studio and IntelliJ)
 69 | com_crashlytics_export_strings.xml
 70 | crashlytics.properties
 71 | crashlytics-build.properties
 72 | fabric.properties
 73 | 
 74 | # Editor-based Rest Client
 75 | .idea/httpRequests
 76 | 
 77 | # Android studio 3.1+ serialized cache file
 78 | .idea/caches/build_file_checksums.ser
 79 | 
 80 | ### Intellij+all Patch ###
 81 | # Ignore everything but code style settings and run configurations
 82 | # that are supposed to be shared within teams.
 83 | 
 84 | .idea/*
 85 | 
 86 | !.idea/codeStyles
 87 | !.idea/runConfigurations
 88 | 
 89 | ### Rust ###
 90 | # Generated by Cargo
 91 | # will have compiled files and executables
 92 | debug/
 93 | target/
 94 | 
 95 | # Remove Cargo.lock from gitignore if creating an executable, leave it for libraries
 96 | # More information here https://doc.rust-lang.org/cargo/guide/cargo-toml-vs-cargo-lock.html
 97 | Cargo.lock
 98 | 
 99 | # These are backup files generated by rustfmt
100 | **/*.rs.bk
101 | 
102 | # MSVC Windows builds of rustc generate these, which store debugging information
103 | *.pdb
104 | 
105 | ### Vim ###
106 | # Swap
107 | [._]*.s[a-v][a-z]
108 | !*.svg  # comment out if you don't need vector files
109 | [._]*.sw[a-p]
110 | [._]s[a-rt-v][a-z]
111 | [._]ss[a-gi-z]
112 | [._]sw[a-p]
113 | 
114 | # Session
115 | Session.vim
116 | Sessionx.vim
117 | 
118 | # Temporary
119 | .netrwhist
120 | *~
121 | # Auto-generated tag files
122 | tags
123 | # Persistent undo
124 | [._]*.un~
125 | 
126 | ### VisualStudioCode ###
127 | .vscode/*
128 | !.vscode/settings.json
129 | !.vscode/tasks.json
130 | !.vscode/launch.json
131 | !.vscode/extensions.json
132 | !.vscode/*.code-snippets
133 | 
134 | # Local History for Visual Studio Code
135 | .history/
136 | 
137 | # Built Visual Studio Code Extensions
138 | *.vsix
139 | 
140 | ### VisualStudioCode Patch ###
141 | # Ignore all local history of files
142 | .history
143 | .ionide


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
  1 | HTML Minifier
  2 | ====================
  3 | 
  4 | [![CI](https://github.com/magiclen/html-minifier/actions/workflows/ci.yml/badge.svg)](https://github.com/magiclen/html-minifier/actions/workflows/ci.yml)
  5 | 
  6 | This library can help you generate and minify your HTML code at the same time. It also supports to minify JS and CSS in `<style>`, `<script>` elements, and ignores the minification of `<pre>`, `<code>` and `<textarea>` elements.
  7 | 
  8 | HTML is minified by the following rules:
  9 | 
 10 | * ASCII control characters (0x00-0x08, 0x11-0x1F, 0x7F) are always removed.
 11 | * Comments can be optionally removed. (removed by default)
 12 | * **Useless** whitespaces (spaces, tabs and newlines) are removed.
 13 | * Whitespaces (spaces, tabs and newlines) are converted to a single `'\x20'` or a single '\n', if possible.
 14 | * Empty attribute values are collapsed. (e.g `<input readonly="">` => `<input readonly>` )
 15 | * The inner HTML of all elements is minified except for the following elements:
 16 |   * `<pre>`
 17 |   * `<textarea>`
 18 |   * `<code>` (optionally, minified by default)
 19 |   * `<style>` (if the `type` attribute is unsupported)
 20 |   * `<script>` (if the `type` attribute is unsupported)
 21 | * JS code and CSS code in `<script>` and `<style>` elements are minified by [minifier](https://crates.io/crates/minifier).
 22 | 
 23 | The original (non-minified) HTML doesn't need to be completely generated before using this library because this library doesn't do any deserialization to create DOMs.
 24 | 
 25 | ## Examples
 26 | 
 27 | ```rust
 28 | use html_minifier::HTMLMinifier;
 29 | 
 30 | let mut html_minifier = HTMLMinifier::new();
 31 | 
 32 | html_minifier.digest("<!DOCTYPE html>   <html  ").unwrap();
 33 | html_minifier.digest("lang=  en >").unwrap();
 34 | html_minifier.digest("
 35 | <head>
 36 |     <meta name=viewport>
 37 | </head>
 38 | ").unwrap();
 39 | html_minifier.digest("
 40 | <body class=' container   bg-light '>
 41 |     <input type='text' value='123   456' readonly=''  />
 42 | 
 43 |     123456
 44 |     <b>big</b> 789
 45 |     ab
 46 |     c
 47 |     中文
 48 |     字
 49 | </body>
 50 | ").unwrap();
 51 | html_minifier.digest("</html  >").unwrap();
 52 | 
 53 | assert_eq!("<!DOCTYPE html> <html lang=en>
 54 | <head>
 55 | <meta name=viewport>
 56 | </head>
 57 | <body class='container bg-light'>
 58 | <input type='text' value='123   456' readonly/>
 59 | 123456
 60 | <b>big</b> 789
 61 | ab
 62 | c
 63 | 中文
 64 | 字
 65 | </body>
 66 | </html>".as_bytes(), html_minifier.get_html());
 67 | ```
 68 | 
 69 | ```rust
 70 | use html_minifier::HTMLMinifier;
 71 | 
 72 | let mut html_minifier = HTMLMinifier::new();
 73 | 
 74 | html_minifier.digest("<pre  >   Hello  world!   </pre  >").unwrap();
 75 | 
 76 | assert_eq!(b"<pre>   Hello  world!   </pre>", html_minifier.get_html());
 77 | ```
 78 | 
 79 | ```rust
 80 | use html_minifier::HTMLMinifier;
 81 | 
 82 | let mut html_minifier = HTMLMinifier::new();
 83 | 
 84 | html_minifier.digest("<script type='  application/javascript '>   alert('Hello!')    ;   </script>").unwrap();
 85 | 
 86 | assert_eq!("<script type='application/javascript'>alert('Hello!')</script>".as_bytes(), html_minifier.get_html());
 87 | ```
 88 | 
 89 | ## Write HTML to a Writer
 90 | 
 91 | If you don't want to store your HTML in memory (e.g. writing to a file instead), you can use the `HTMLMinifierHelper` struct which provides a low-level API that allows you to pass your output instance when invoking the `digest` method.
 92 | 
 93 | ```rust
 94 | use html_minifier::HTMLMinifierHelper;
 95 | 
 96 | use std::fs::File;
 97 | use std::io::Read;
 98 | 
 99 | let mut input_file = File::open("tests/data/w3schools.com_tryhow_css_example_website.htm").unwrap();
100 | let mut output_file = File::create("tests/data/index.min.html").unwrap();
101 | 
102 | let mut buffer = [0u8; 256];
103 | 
104 | let mut html_minifier_helper = HTMLMinifierHelper::new();
105 | 
106 | loop {
107 |     let c = input_file.read(&mut buffer).unwrap();
108 | 
109 |     if c == 0 {
110 |         break;
111 |     }
112 | 
113 |     html_minifier_helper.digest(&buffer[..c], &mut output_file).unwrap();
114 | }
115 | ```
116 | 
117 | ## Crates.io
118 | 
119 | https://crates.io/crates/html-minifier
120 | 
121 | ## Documentation
122 | 
123 | https://docs.rs/html-minifier
124 | 
125 | ## License
126 | 
127 | [MIT](LICENSE)


--------------------------------------------------------------------------------
/tests/data/w3schools.com_tryhow_css_example_website.htm:
--------------------------------------------------------------------------------
  1 | <!DOCTYPE html>
  2 | <html lang="en">
  3 | <head>
  4 |     <title>Page Title</title>
  5 |     <meta charset="UTF-8">
  6 |     <meta name="viewport" content="width=device-width, initial-scale=1">
  7 |     <style>
  8 |         * {
  9 |             box-sizing: border-box;
 10 |         }
 11 | 
 12 |         /* Style the body */
 13 |         body {
 14 |             font-family: Arial, Helvetica, sans-serif;
 15 |             margin: 0;
 16 |         }
 17 | 
 18 |         /* Header/logo Title */
 19 |         .header {
 20 |             padding: 80px;
 21 |             text-align: center;
 22 |             background: #1abc9c;
 23 |             color: white;
 24 |         }
 25 | 
 26 |         /* Increase the font size of the heading */
 27 |         .header h1 {
 28 |             font-size: 40px;
 29 |         }
 30 | 
 31 |         /* Sticky navbar - toggles between relative and fixed, depending on the scroll position. It is positioned relative until a given offset position is met in the viewport - then it "sticks" in place (like position:fixed). The sticky value is not supported in IE or Edge 15 and earlier versions. However, for these versions the navbar will inherit default position */
 32 |         .navbar {
 33 |             overflow: hidden;
 34 |             background-color: #333;
 35 |             position: sticky;
 36 |             position: -webkit-sticky;
 37 |             top: 0;
 38 |         }
 39 | 
 40 |         /* Style the navigation bar links */
 41 |         .navbar a {
 42 |             float: left;
 43 |             display: block;
 44 |             color: white;
 45 |             text-align: center;
 46 |             padding: 14px 20px;
 47 |             text-decoration: none;
 48 |         }
 49 | 
 50 | 
 51 |         /* Right-aligned link */
 52 |         .navbar a.right {
 53 |             float: right;
 54 |         }
 55 | 
 56 |         /* Change color on hover */
 57 |         .navbar a:hover {
 58 |             background-color: #ddd;
 59 |             color: black;
 60 |         }
 61 | 
 62 |         /* Active/current link */
 63 |         .navbar a.active {
 64 |             background-color: #666;
 65 |             color: white;
 66 |         }
 67 | 
 68 |         /* Column container */
 69 |         .row {
 70 |             display: -ms-flexbox; /* IE10 */
 71 |             display: flex;
 72 |             -ms-flex-wrap: wrap; /* IE10 */
 73 |             flex-wrap: wrap;
 74 |         }
 75 | 
 76 |         /* Create two unequal columns that sits next to each other */
 77 |         /* Sidebar/left column */
 78 |         .side {
 79 |             -ms-flex: 30%; /* IE10 */
 80 |             flex: 30%;
 81 |             background-color: #f1f1f1;
 82 |             padding: 20px;
 83 |         }
 84 | 
 85 |         /* Main column */
 86 |         .main {
 87 |             -ms-flex: 70%; /* IE10 */
 88 |             flex: 70%;
 89 |             background-color: white;
 90 |             padding: 20px;
 91 |         }
 92 | 
 93 |         /* Fake image, just for this example */
 94 |         .fakeimg {
 95 |             background-color: #aaa;
 96 |             width: 100%;
 97 |             padding: 20px;
 98 |         }
 99 | 
100 |         /* Footer */
101 |         .footer {
102 |             padding: 20px;
103 |             text-align: center;
104 |             background: #ddd;
105 |         }
106 | 
107 |         /* Responsive layout - when the screen is less than 700px wide, make the two columns stack on top of each other instead of next to each other */
108 |         @media screen and (max-width: 700px) {
109 |             .row {
110 |                 flex-direction: column;
111 |             }
112 |         }
113 | 
114 |         /* Responsive layout - when the screen is less than 400px wide, make the navigation links stack on top of each other instead of next to each other */
115 |         @media screen and (max-width: 400px) {
116 |             .navbar a {
117 |                 float: none;
118 |                 width: 100%;
119 |             }
120 |         }
121 |     </style>
122 | </head>
123 | <body>
124 | 
125 | <div class="header">
126 |     <h1>My Website</h1>
127 |     <p>A <b>responsive</b> website created by me.</p>
128 | </div>
129 | 
130 | <div class="navbar">
131 |     <a href="#" class="active">Home</a>
132 |     <a href="#">Link</a>
133 |     <a href="#">Link</a>
134 |     <a href="#" class="right">Link</a>
135 | </div>
136 | 
137 | <div class="row">
138 |     <div class="side">
139 |         <h2>About Me</h2>
140 |         <h5>Photo of me:</h5>
141 |         <div class="fakeimg" style="height:200px;">Image</div>
142 |         <p>Some text about me in culpa qui officia deserunt mollit anim..</p>
143 |         <h3>More Text</h3>
144 |         <p>Lorem ipsum dolor sit ame.</p>
145 |         <div class="fakeimg" style="height:60px;">Image</div>
146 |         <br>
147 |         <div class="fakeimg" style="height:60px;">Image</div>
148 |         <br>
149 |         <div class="fakeimg" style="height:60px;">Image</div>
150 |     </div>
151 |     <div class="main">
152 |         <h2>TITLE HEADING</h2>
153 |         <h5>Title description, Dec 7, 2017</h5>
154 |         <div class="fakeimg" style="height:200px;">Image</div>
155 |         <p>Some text..</p>
156 |         <p>Sunt in culpa qui officia deserunt mollit anim id est laborum consectetur adipiscing elit, sed do eiusmod
157 |             tempor incididunt ut labore et dolore magna aliqua. Ut enim ad minim veniam, quis nostrud exercitation
158 |             ullamco.</p>
159 |         <br>
160 |         <h2>TITLE HEADING</h2>
161 |         <h5>Title description, Sep 2, 2017</h5>
162 |         <div class="fakeimg" style="height:200px;">Image</div>
163 |         <p>Some text..</p>
164 |         <p>Sunt in culpa qui officia deserunt mollit anim id est laborum consectetur adipiscing elit, sed do eiusmod
165 |             tempor incididunt ut labore et dolore magna aliqua. Ut enim ad minim veniam, quis nostrud exercitation
166 |             ullamco.</p>
167 |     </div>
168 | </div>
169 | 
170 | <div class="footer">
171 |     <h2>Footer</h2>
172 | </div>
173 | 
174 | </body>
175 | </html>
176 | 


--------------------------------------------------------------------------------
/src/lib.rs:
--------------------------------------------------------------------------------
  1 | /*!
  2 | # HTML Minifier
  3 | 
  4 | This library can help you generate and minify your HTML code at the same time. It also supports to minify JS and CSS in `<style>`, `<script>` elements, and ignores the minification of `<pre>`, `<code>` and `<textarea>` elements.
  5 | 
  6 | HTML is minified by the following rules:
  7 | 
  8 | * ASCII control characters (0x00-0x08, 0x11-0x1F, 0x7F) are always removed.
  9 | * Comments can be optionally removed. (removed by default)
 10 | * **Useless** whitespaces (spaces, tabs and newlines) are removed.
 11 | * Whitespaces (spaces, tabs and newlines) are converted to a single `'\x20'` or a single '\n', if possible.
 12 | * Empty attribute values are collapsed. (e.g `<input readonly="">` => `<input readonly>` )
 13 | * The inner HTML of all elements is minified except for the following elements:
 14 |     * `<pre>`
 15 |     * `<textarea>`
 16 |     * `<code>` (optionally, minified by default)
 17 |     * `<style>` (if the `type` attribute is unsupported)
 18 |     * `<script>` (if the `type` attribute is unsupported)
 19 | * JS code and CSS code in `<script>` and `<style>` elements are minified by [minifier](https://crates.io/crates/minifier).
 20 | 
 21 | The original (non-minified) HTML doesn't need to be completely generated before using this library because this library doesn't do any deserialization to create DOMs.
 22 | 
 23 | ## Examples
 24 | 
 25 | ```rust
 26 | use html_minifier::HTMLMinifier;
 27 | 
 28 | let mut html_minifier = HTMLMinifier::new();
 29 | 
 30 | html_minifier.digest("<!DOCTYPE html>   <html  ").unwrap();
 31 | html_minifier.digest("lang=  en >").unwrap();
 32 | html_minifier.digest("
 33 | <head>
 34 |     <meta name=viewport>
 35 | </head>
 36 | ").unwrap();
 37 | html_minifier.digest("
 38 | <body class=' container   bg-light '>
 39 |     <input type='text' value='123   456' readonly=''  />
 40 | 
 41 |     123456
 42 |     <b>big</b> 789
 43 |     ab
 44 |     c
 45 |     中文
 46 |     字
 47 | </body>
 48 | ").unwrap();
 49 | html_minifier.digest("</html  >").unwrap();
 50 | 
 51 | assert_eq!("<!DOCTYPE html> <html lang=en>
 52 | <head>
 53 | <meta name=viewport>
 54 | </head>
 55 | <body class='container bg-light'>
 56 | <input type='text' value='123   456' readonly/>
 57 | 123456
 58 | <b>big</b> 789
 59 | ab
 60 | c
 61 | 中文
 62 | 字
 63 | </body>
 64 | </html>".as_bytes(), html_minifier.get_html());
 65 | ```
 66 | 
 67 | ```rust
 68 | use html_minifier::HTMLMinifier;
 69 | 
 70 | let mut html_minifier = HTMLMinifier::new();
 71 | 
 72 | html_minifier.digest("<pre  >   Hello  world!   </pre  >").unwrap();
 73 | 
 74 | assert_eq!(b"<pre>   Hello  world!   </pre>", html_minifier.get_html());
 75 | ```
 76 | 
 77 | ```rust
 78 | use html_minifier::HTMLMinifier;
 79 | 
 80 | let mut html_minifier = HTMLMinifier::new();
 81 | 
 82 | html_minifier.digest("<script type='  application/javascript '>   alert('Hello!')    ;   </script>").unwrap();
 83 | 
 84 | assert_eq!("<script type='application/javascript'>alert('Hello!')</script>".as_bytes(), html_minifier.get_html());
 85 | ```
 86 | 
 87 | ## Write HTML to a Writer
 88 | 
 89 | If you don't want to store your HTML in memory (e.g. writing to a file instead), you can use the `HTMLMinifierHelper` struct which provides a low-level API that allows you to pass your output instance when invoking the `digest` method.
 90 | 
 91 | ```rust
 92 | use html_minifier::HTMLMinifierHelper;
 93 | 
 94 | use std::fs::File;
 95 | use std::io::Read;
 96 | 
 97 | let mut input_file = File::open("tests/data/w3schools.com_tryhow_css_example_website.htm").unwrap();
 98 | let mut output_file = File::create("tests/data/index.min.html").unwrap();
 99 | 
100 | let mut buffer = [0u8; 256];
101 | 
102 | let mut html_minifier_helper = HTMLMinifierHelper::new();
103 | 
104 | loop {
105 |     let c = input_file.read(&mut buffer).unwrap();
106 | 
107 |     if c == 0 {
108 |         break;
109 |     }
110 | 
111 |     html_minifier_helper.digest(&buffer[..c], &mut output_file).unwrap();
112 | }
113 | ```
114 | */
115 | mod errors;
116 | mod functions;
117 | mod html_minifier_helper;
118 | mod html_writer;
119 | 
120 | use educe::Educe;
121 | pub use errors::*;
122 | pub use html_minifier_helper::*;
123 | pub use html_writer::*;
124 | 
125 | use crate::functions::*;
126 | 
127 | /// This struct helps you generate and minify your HTML code in the same time. The output destination is inside this struct.
128 | #[derive(Educe, Clone)]
129 | #[educe(Debug, Default(new))]
130 | pub struct HTMLMinifier {
131 |     helper: HTMLMinifierHelper,
132 |     #[educe(Debug(method = "str_bytes_fmt"))]
133 |     out:    Vec<u8>,
134 | }
135 | 
136 | impl HTMLMinifier {
137 |     /// Set whether to remove HTML comments.
138 |     #[inline]
139 |     pub fn set_remove_comments(&mut self, remove_comments: bool) {
140 |         self.helper.remove_comments = remove_comments;
141 |     }
142 | 
143 |     /// Set whether to minify the content in the `code` element.
144 |     #[inline]
145 |     pub fn set_minify_code(&mut self, minify_code: bool) {
146 |         self.helper.minify_code = minify_code;
147 |     }
148 | 
149 |     /// Get whether to remove HTML comments.
150 |     #[inline]
151 |     pub const fn get_remove_comments(&self) -> bool {
152 |         self.helper.remove_comments
153 |     }
154 | 
155 |     /// Get whether to minify the content in the `code` element.
156 |     #[inline]
157 |     pub const fn get_minify_code(&self) -> bool {
158 |         self.helper.minify_code
159 |     }
160 | }
161 | 
162 | impl HTMLMinifier {
163 |     /// Reset this html minifier. The option settings and allocated memory will be be preserved.
164 |     #[inline]
165 |     pub fn reset(&mut self) {
166 |         self.helper.reset();
167 |         self.out.clear();
168 |     }
169 | }
170 | 
171 | impl HTMLMinifier {
172 |     /// Input some text to generate HTML code. It is not necessary to input a full HTML text at once.
173 |     #[inline]
174 |     pub fn digest<S: AsRef<[u8]>>(&mut self, text: S) -> Result<(), HTMLMinifierError> {
175 |         let text = text.as_ref();
176 | 
177 |         self.out.reserve(text.len());
178 | 
179 |         self.helper.digest(text, &mut self.out)
180 |     }
181 | 
182 |     /// Directly input some text to generate HTML code. The text will just be appended to the output buffer instead of being through the helper.
183 |     ///
184 |     /// # When to Use This?
185 |     ///
186 |     /// If the text has been minified, you can consider to use this method to get a better performance.
187 |     #[allow(clippy::missing_safety_doc)]
188 |     #[inline]
189 |     pub unsafe fn indigest<S: AsRef<[u8]>>(&mut self, text: S) {
190 |         self.out.extend_from_slice(text.as_ref());
191 |     }
192 | }
193 | 
194 | impl HTMLMinifier {
195 |     /// Get HTML in a string slice.
196 |     #[inline]
197 |     pub fn get_html(&mut self) -> &[u8] {
198 |         self.out.as_slice()
199 |     }
200 | }
201 | 
202 | /// Minify HTML.
203 | #[inline]
204 | pub fn minify<S: AsRef<str>>(html: S) -> Result<String, HTMLMinifierError> {
205 |     let mut minifier = HTMLMinifierHelper::new();
206 | 
207 |     let html = html.as_ref();
208 | 
209 |     let mut minified_html = String::with_capacity(html.len());
210 | 
211 |     minifier.digest(html, unsafe { minified_html.as_mut_vec() })?;
212 | 
213 |     Ok(minified_html)
214 | }
215 | 


--------------------------------------------------------------------------------
/tests/mix.rs:
--------------------------------------------------------------------------------
  1 | use html_minifier::HTMLMinifier;
  2 | 
  3 | #[test]
  4 | fn reset() {
  5 |     let mut html_minifier = HTMLMinifier::new();
  6 | 
  7 |     html_minifier.digest("1").unwrap();
  8 | 
  9 |     html_minifier.reset();
 10 | 
 11 |     html_minifier.digest("23").unwrap();
 12 | 
 13 |     assert_eq!(b"23", html_minifier.get_html());
 14 | }
 15 | 
 16 | #[test]
 17 | fn remove_ascii_control_characters() {
 18 |     let mut html_minifier = HTMLMinifier::new();
 19 | 
 20 |     html_minifier.digest("\x00<html>").unwrap();
 21 | 
 22 |     assert_eq!(b"<html>", html_minifier.get_html());
 23 | }
 24 | 
 25 | #[test]
 26 | fn remove_useless_whitespaces_from_start() {
 27 |     let mut html_minifier = HTMLMinifier::new();
 28 | 
 29 |     html_minifier.digest("  \n \t123").unwrap();
 30 | 
 31 |     assert_eq!(b"123", html_minifier.get_html());
 32 | }
 33 | 
 34 | #[test]
 35 | fn remove_useless_whitespaces_from_end() {
 36 |     let mut html_minifier = HTMLMinifier::new();
 37 | 
 38 |     html_minifier.digest("123  \n \t").unwrap();
 39 | 
 40 |     assert_eq!(b"123", html_minifier.get_html());
 41 | }
 42 | 
 43 | #[test]
 44 | fn remove_useless_whitespaces_from_tag() {
 45 |     let mut html_minifier = HTMLMinifier::new();
 46 | 
 47 |     {
 48 |         html_minifier.digest("<div  >").unwrap();
 49 | 
 50 |         assert_eq!(b"<div>", html_minifier.get_html());
 51 |     }
 52 | 
 53 |     html_minifier.reset();
 54 | 
 55 |     {
 56 |         html_minifier.digest("</div   >").unwrap();
 57 | 
 58 |         assert_eq!(b"</div>", html_minifier.get_html());
 59 |     }
 60 | 
 61 |     html_minifier.reset();
 62 | 
 63 |     {
 64 |         html_minifier.digest("<hr  /  >").unwrap();
 65 | 
 66 |         assert_eq!(b"<hr/>", html_minifier.get_html());
 67 |     }
 68 | 
 69 |     html_minifier.reset();
 70 | 
 71 |     {
 72 |         html_minifier.digest(r#"<div   id="name  xxx"    class="  col-1   col-md-5 ">"#).unwrap();
 73 | 
 74 |         assert_eq!(
 75 |             r#"<div id="name  xxx" class="col-1 col-md-5">"#.as_bytes(),
 76 |             html_minifier.get_html()
 77 |         );
 78 |     }
 79 | 
 80 |     html_minifier.reset();
 81 | 
 82 |     {
 83 |         html_minifier.digest(r#"<div   id="name  xxx"    class="">"#).unwrap();
 84 | 
 85 |         assert_eq!(r#"<div id="name  xxx" class>"#.as_bytes(), html_minifier.get_html());
 86 |     }
 87 | 
 88 |     html_minifier.reset();
 89 | 
 90 |     {
 91 |         html_minifier.digest(r#"<div   id="name  xxx"    class="  ">"#).unwrap();
 92 | 
 93 |         assert_eq!(r#"<div id="name  xxx" class>"#.as_bytes(), html_minifier.get_html());
 94 |     }
 95 | 
 96 |     html_minifier.reset();
 97 | 
 98 |     {
 99 |         html_minifier.digest(r#"<input type="text"  value="123   45"  / >"#).unwrap();
100 | 
101 |         assert_eq!(r#"<input type="text" value="123   45"/>"#.as_bytes(), html_minifier.get_html());
102 |     }
103 | 
104 |     html_minifier.reset();
105 | 
106 |     {
107 |         html_minifier.digest(r#"<input type="text"  value=123  / >"#).unwrap();
108 | 
109 |         assert_eq!(br#"<input type="text" value=123 />"#.as_ref(), html_minifier.get_html());
110 |     }
111 | }
112 | 
113 | #[test]
114 | fn remove_useless_whitespaces_from_content() {
115 |     let mut html_minifier = HTMLMinifier::new();
116 | 
117 |     {
118 |         html_minifier.digest("a   b").unwrap();
119 | 
120 |         assert_eq!(b"a b", html_minifier.get_html());
121 |     }
122 | 
123 |     html_minifier.reset();
124 | 
125 |     {
126 |         html_minifier.digest("a \t\t\t  b").unwrap();
127 | 
128 |         assert_eq!(b"a b", html_minifier.get_html());
129 |     }
130 | 
131 |     html_minifier.reset();
132 | 
133 |     {
134 |         html_minifier.digest("a \n b").unwrap();
135 | 
136 |         assert_eq!(b"a\nb", html_minifier.get_html());
137 |     }
138 | 
139 |     html_minifier.reset();
140 | 
141 |     {
142 |         html_minifier.digest("a\n<span>b</span>").unwrap();
143 | 
144 |         assert_eq!(b"a\n<span>b</span>", html_minifier.get_html());
145 |     }
146 | 
147 |     html_minifier.reset();
148 | 
149 |     {
150 |         html_minifier.digest("<span>a  </span>  <span>  b</span>").unwrap();
151 | 
152 |         assert_eq!(b"<span>a </span> <span> b</span>", html_minifier.get_html());
153 |     }
154 | 
155 |     html_minifier.reset();
156 | 
157 |     {
158 |         html_minifier.digest("<a>1</a>\n /\n <a>2</a>").unwrap();
159 | 
160 |         assert_eq!(b"<a>1</a>\n/\n<a>2</a>", html_minifier.get_html());
161 |     }
162 | 
163 |     html_minifier.reset();
164 | 
165 |     {
166 |         html_minifier.digest("中   文").unwrap();
167 | 
168 |         assert_eq!("中 文".as_bytes(), html_minifier.get_html());
169 |     }
170 | 
171 |     html_minifier.reset();
172 | 
173 |     {
174 |         html_minifier.digest("中 \t\t\t  文").unwrap();
175 | 
176 |         assert_eq!("中 文".as_bytes(), html_minifier.get_html());
177 |     }
178 | 
179 |     html_minifier.reset();
180 | 
181 |     {
182 |         html_minifier.digest("中 \n 文").unwrap();
183 | 
184 |         assert_eq!("中\n文".as_bytes(), html_minifier.get_html());
185 |     }
186 | 
187 |     html_minifier.reset();
188 | 
189 |     {
190 |         html_minifier.digest("中\n<span>文</span>").unwrap();
191 | 
192 |         assert_eq!("中\n<span>文</span>".as_bytes(), html_minifier.get_html());
193 |     }
194 | 
195 |     html_minifier.reset();
196 | 
197 |     {
198 |         html_minifier.digest("<span>中  </span>  <span>  文</span>").unwrap();
199 | 
200 |         assert_eq!("<span>中 </span> <span> 文</span>".as_bytes(), html_minifier.get_html());
201 |     }
202 | }
203 | 
204 | #[test]
205 | fn text_mix_basic() {
206 |     let mut html_minifier = HTMLMinifier::new();
207 | 
208 |     {
209 |         html_minifier
210 |             .digest(
211 |                 r#"
212 |                 <!DOCTYPE html>
213 |                 <html lang=en>
214 |                     <head >
215 |                         <meta  name=viewport  >
216 |                     </head  >
217 |                     <body     class="container    bg-light" >
218 |                         <input type="text" value='123   456'    />
219 |                         <!-- Content -->
220 |                         123456 <b>big</b> 789
221 | 
222 |                     </body >
223 |                 </html >
224 |         "#,
225 |             )
226 |             .unwrap();
227 | 
228 |         assert_eq!(
229 |             r#"<!DOCTYPE html>
230 | <html lang=en>
231 | <head>
232 | <meta name=viewport>
233 | </head>
234 | <body class="container bg-light">
235 | <input type="text" value='123   456'/>
236 | 123456 <b>big</b> 789
237 | </body>
238 | </html>"#
239 |                 .as_bytes(),
240 |             html_minifier.get_html()
241 |         );
242 |     }
243 | }
244 | 
245 | #[test]
246 | fn minify_css() {
247 |     let mut html_minifier = HTMLMinifier::new();
248 | 
249 |     {
250 |         html_minifier
251 |             .digest(
252 |                 r#"<style  >
253 | h1 {
254 |     color: blue;
255 |     font-family: verdana;
256 |     font-size: 300%;
257 | }
258 | p  {
259 |     color: red;
260 |     font-family: courier;
261 |     font-size: 160%;
262 | }
263 |         </style >"#,
264 |             )
265 |             .unwrap();
266 | 
267 |         assert_eq!(
268 |             "<style>h1{color:blue;font-family:verdana;font-size:300%;}p{color:red;font-family:\
269 |              courier;font-size:160%;}</style>"
270 |                 .as_bytes(),
271 |             html_minifier.get_html()
272 |         );
273 |     }
274 | 
275 |     html_minifier.reset();
276 | 
277 |     {
278 |         html_minifier
279 |             .digest(
280 |                 r#"<style  type="  text/css  "  >
281 | h1 {
282 |     color: blue;
283 |     font-family: verdana;
284 |     font-size: 300%;
285 | }
286 | p  {
287 |     color: red;
288 |     font-family: courier;
289 |     font-size: 160%;
290 | }
291 |         </style >"#,
292 |             )
293 |             .unwrap();
294 | 
295 |         assert_eq!(
296 |             r#"<style type="text/css">h1{color:blue;font-family:verdana;font-size:300%;}p{color:red;font-family:courier;font-size:160%;}</style>"#.as_bytes(),
297 |             html_minifier.get_html()
298 |         );
299 |     }
300 | }
301 | 
302 | #[test]
303 | fn minify_javascript() {
304 |     let mut html_minifier = HTMLMinifier::new();
305 | 
306 |     {
307 |         html_minifier
308 |             .digest(
309 |                 r#"<script  >
310 |         alert('1234!')    ;
311 | 
312 |         </script >"#,
313 |             )
314 |             .unwrap();
315 | 
316 |         assert_eq!(b"<script>alert('1234!')</script>", html_minifier.get_html());
317 |     }
318 | 
319 |     html_minifier.reset();
320 | 
321 |     {
322 |         html_minifier
323 |             .digest(
324 |                 r#"<script  type="  application/javascript  "  >
325 |         alert('1234!')    ;
326 | 
327 |         </script >"#,
328 |             )
329 |             .unwrap();
330 | 
331 |         assert_eq!(
332 |             r#"<script type="application/javascript">alert('1234!')</script>"#.as_bytes(),
333 |             html_minifier.get_html()
334 |         );
335 |     }
336 | }
337 | 
338 | #[test]
339 | fn minify_javascript_css() {
340 |     let mut html_minifier = HTMLMinifier::new();
341 | 
342 |     {
343 |         html_minifier
344 |             .digest(
345 |                 r#"<script  >
346 |         alert('1234!')    ;
347 | 
348 |         </script ><style  >
349 | h1 {
350 |     color: blue;
351 |     font-family: verdana;
352 |     font-size: 300%;
353 | }
354 | p  {
355 |     color: red;
356 |     font-family: courier;
357 |     font-size: 160%;
358 | }
359 |         </style >"#,
360 |             )
361 |             .unwrap();
362 | 
363 |         assert_eq!(
364 |             "<script>alert('1234!')</script><style>h1{color:blue;font-family:verdana;font-size:\
365 |              300%;}p{color:red;font-family:courier;font-size:160%;}</style>"
366 |                 .as_bytes(),
367 |             html_minifier.get_html()
368 |         );
369 |     }
370 | }
371 | 
372 | #[test]
373 | fn preserve_pre() {
374 |     let mut html_minifier = HTMLMinifier::new();
375 | 
376 |     {
377 |         html_minifier
378 |             .digest(
379 |                 r#"<pre   lang="html"  >
380 |     <html>
381 |         1234567
382 |     </html></pre>
383 |     <div>
384 |         1234567
385 |     </div>
386 |     <pre>
387 |         1234567
388 |     </pre   >"#,
389 |             )
390 |             .unwrap();
391 | 
392 |         assert_eq!(
393 |             r#"<pre lang="html">
394 |     <html>
395 |         1234567
396 |     </html></pre>
397 | <div>
398 | 1234567
399 | </div>
400 | <pre>
401 |         1234567
402 |     </pre>"#
403 |                 .as_bytes(),
404 |             html_minifier.get_html()
405 |         );
406 |     }
407 | }
408 | 
409 | #[test]
410 | fn preserve_code() {
411 |     let mut html_minifier = HTMLMinifier::new();
412 |     html_minifier.set_minify_code(false);
413 | 
414 |     {
415 |         html_minifier
416 |             .digest(
417 |                 r#"<code   lang="html"  >
418 |     <html>
419 |         1234567
420 |     </html></code>
421 |     <div>
422 |         1234567
423 |     </div>
424 |     <code>
425 |         1234567
426 |     </code   >"#,
427 |             )
428 |             .unwrap();
429 | 
430 |         assert_eq!(
431 |             r#"<code lang="html">
432 |     <html>
433 |         1234567
434 |     </html></code>
435 | <div>
436 | 1234567
437 | </div>
438 | <code>
439 |         1234567
440 |     </code>"#
441 |                 .as_bytes(),
442 |             html_minifier.get_html()
443 |         );
444 |     }
445 | }
446 | 
447 | #[test]
448 | fn preserve_textarea() {
449 |     let mut html_minifier = HTMLMinifier::new();
450 | 
451 |     {
452 |         html_minifier
453 |             .digest(
454 |                 r#"<textarea   class="control"  >Hi,
455 | 
456 | This is a textarea.
457 | You can write multi-line messages here.
458 | </textarea>
459 |     <div>
460 |         1234567
461 |     </div>
462 |     <textarea>
463 |         1234567
464 |     </textarea   >"#,
465 |             )
466 |             .unwrap();
467 | 
468 |         assert_eq!(
469 |             r#"<textarea class="control">Hi,
470 | 
471 | This is a textarea.
472 | You can write multi-line messages here.
473 | </textarea>
474 | <div>
475 | 1234567
476 | </div>
477 | <textarea>
478 |         1234567
479 |     </textarea>"#
480 |                 .as_bytes(),
481 |             html_minifier.get_html()
482 |         );
483 |     }
484 | }
485 | 
486 | #[test]
487 | fn preserve_unsupported_script_type() {
488 |     let mut html_minifier = HTMLMinifier::new();
489 | 
490 |     {
491 |         html_minifier
492 |             .digest(
493 |                 r#"<script  type="  application/ecmascript  "  >
494 |         alert('1234!')    ;
495 | 
496 |         </script >"#,
497 |             )
498 |             .unwrap();
499 | 
500 |         assert_eq!(
501 |             r#"<script type="application/ecmascript">
502 |         alert('1234!')    ;
503 | 
504 |         </script>"#
505 |                 .as_bytes(),
506 |             html_minifier.get_html()
507 |         );
508 |     }
509 | }
510 | 
511 | #[test]
512 | fn preserve_unsupported_style_type() {
513 |     let mut html_minifier = HTMLMinifier::new();
514 | 
515 |     {
516 |         html_minifier
517 |             .digest(
518 |                 r#"<style  type="  text/x-scss  "  >
519 | h1 {
520 |     color: blue;
521 |     font-family: verdana;
522 |     font-size: 300%;
523 | }
524 | p  {
525 |     color: red;
526 |     font-family: courier;
527 |     font-size: 160%;
528 | }
529 |         </style >"#,
530 |             )
531 |             .unwrap();
532 | 
533 |         assert_eq!(
534 |             r#"<style type="text/x-scss">
535 | h1 {
536 |     color: blue;
537 |     font-family: verdana;
538 |     font-size: 300%;
539 | }
540 | p  {
541 |     color: red;
542 |     font-family: courier;
543 |     font-size: 160%;
544 | }
545 |         </style>"#
546 |                 .as_bytes(),
547 |             html_minifier.get_html()
548 |         );
549 |     }
550 | }
551 | 


--------------------------------------------------------------------------------
/tests/steps.rs:
--------------------------------------------------------------------------------
  1 | use std::str::from_utf8_unchecked;
  2 | 
  3 | use html_minifier::HTMLMinifier;
  4 | 
  5 | fn test_enabled_all_options(cases: &[(&str, &str)]) {
  6 |     for (index, (expect, test)) in cases.iter().copied().enumerate() {
  7 |         let mut html_minifier = HTMLMinifier::new();
  8 |         html_minifier.digest(test).unwrap();
  9 |         assert_eq!(expect.as_bytes(), html_minifier.get_html(), "case {}", index);
 10 |     }
 11 | 
 12 |     let mut buffer = [0u8; 8];
 13 | 
 14 |     for (index, (expect, test)) in cases.iter().copied().enumerate() {
 15 |         let mut html_minifier = HTMLMinifier::new();
 16 | 
 17 |         for c in test.chars() {
 18 |             html_minifier.digest(c.encode_utf8(&mut buffer)).unwrap();
 19 |         }
 20 | 
 21 |         assert_eq!(expect.as_bytes(), html_minifier.get_html(), "case-chunk-1 {}", index);
 22 |     }
 23 | 
 24 |     for (index, (expect, test)) in cases.iter().copied().enumerate() {
 25 |         let mut html_minifier = HTMLMinifier::new();
 26 | 
 27 |         let mut chars = test.chars();
 28 | 
 29 |         while let Some(c) = chars.next() {
 30 |             let mut length = c.encode_utf8(&mut buffer).len();
 31 | 
 32 |             if let Some(c) = chars.next() {
 33 |                 length = length + c.encode_utf8(&mut buffer[length..]).len();
 34 |             }
 35 | 
 36 |             html_minifier.digest(unsafe { from_utf8_unchecked(&buffer[..length]) }).unwrap();
 37 |         }
 38 | 
 39 |         assert_eq!(expect.as_bytes(), html_minifier.get_html(), "case-chunk-2 {}", index);
 40 |     }
 41 | }
 42 | 
 43 | fn test_disabled_all_options(cases: &[(&str, &str)]) {
 44 |     for (index, (expect, test)) in cases.iter().copied().enumerate() {
 45 |         let mut html_minifier = HTMLMinifier::new();
 46 |         html_minifier.set_remove_comments(false);
 47 |         html_minifier.set_minify_code(false);
 48 | 
 49 |         html_minifier.digest(test).unwrap();
 50 |         assert_eq!(expect.as_bytes(), html_minifier.get_html(), "case {}", index);
 51 |     }
 52 | 
 53 |     let mut buffer = [0u8; 8];
 54 | 
 55 |     for (index, (expect, test)) in cases.iter().copied().enumerate() {
 56 |         let mut html_minifier = HTMLMinifier::new();
 57 |         html_minifier.set_remove_comments(false);
 58 |         html_minifier.set_minify_code(false);
 59 | 
 60 |         for c in test.chars() {
 61 |             html_minifier.digest(c.encode_utf8(&mut buffer)).unwrap();
 62 |         }
 63 | 
 64 |         assert_eq!(expect.as_bytes(), html_minifier.get_html(), "case-chunk-1 {}", index);
 65 |     }
 66 | 
 67 |     for (index, (expect, test)) in cases.iter().copied().enumerate() {
 68 |         let mut html_minifier = HTMLMinifier::new();
 69 |         html_minifier.set_remove_comments(false);
 70 |         html_minifier.set_minify_code(false);
 71 | 
 72 |         let mut chars = test.chars();
 73 | 
 74 |         while let Some(c) = chars.next() {
 75 |             let mut length = c.encode_utf8(&mut buffer).len();
 76 | 
 77 |             if let Some(c) = chars.next() {
 78 |                 length = length + c.encode_utf8(&mut buffer[length..]).len();
 79 |             }
 80 | 
 81 |             html_minifier.digest(unsafe { from_utf8_unchecked(&buffer[..length]) }).unwrap();
 82 |         }
 83 | 
 84 |         assert_eq!(expect.as_bytes(), html_minifier.get_html(), "case-chunk-2 {}", index);
 85 |     }
 86 | }
 87 | 
 88 | #[test]
 89 | fn initial() {
 90 |     const CASES: [(&str, &str); 3] = [("", ""), ("", "   "), ("1", "  1")];
 91 | 
 92 |     test_enabled_all_options(&CASES);
 93 | }
 94 | 
 95 | #[test]
 96 | fn initial_remain_one_whitespace() {
 97 |     const CASES: [(&str, &str); 2] = [("1", "1 "), ("1", "1\t")];
 98 | 
 99 |     test_enabled_all_options(&CASES);
100 | }
101 | 
102 | #[test]
103 | fn initial_ignore_whitespace() {
104 |     const CASES: [(&str, &str); 2] = [("1 23", "1  23"), ("1 234 567", "1  234   567")];
105 | 
106 |     test_enabled_all_options(&CASES);
107 | }
108 | 
109 | #[test]
110 | fn start_tag_initial() {
111 |     const CASES: [(&str, &str); 6] =
112 |         [("", "<>"), ("123", "123<>"), ("<a", "<a"), ("<", "< "), ("<", "<\t"), ("", "<!")];
113 | 
114 |     test_enabled_all_options(&CASES);
115 | }
116 | 
117 | #[test]
118 | fn end_tag_initial() {
119 |     const CASES: [(&str, &str); 5] =
120 |         [("", "</>"), ("123", "123</>"), ("</a", "</a"), ("</", "</ "), ("</", "</\t")];
121 | 
122 |     test_enabled_all_options(&CASES);
123 | }
124 | 
125 | #[test]
126 | fn start_tag() {
127 |     const CASES: [(&str, &str); 4] =
128 |         [("<aaa", "<aaa"), ("<aaa", "<aaa "), ("<aaa/", "<aaa/"), ("<aaa>", "<aaa>")];
129 | 
130 |     test_enabled_all_options(&CASES);
131 | }
132 | 
133 | #[test]
134 | fn start_tag_in() {
135 |     const CASES: [(&str, &str); 6] = [
136 |         ("<aaa/", "<aaa /"),
137 |         ("<aaa/", "<aaa   /"),
138 |         ("<aaa>", "<aaa >"),
139 |         ("<aaa>", "<aaa   >"),
140 |         ("<aaa a", "<aaa a"),
141 |         ("<aaa a", "<aaa   a"),
142 |     ];
143 | 
144 |     test_enabled_all_options(&CASES);
145 | }
146 | 
147 | #[test]
148 | fn start_tag_attribute_name() {
149 |     const CASES: [(&str, &str); 5] = [
150 |         ("<aaa abc", "<aaa abc"),
151 |         ("<aaa abc/", "<aaa abc/"),
152 |         ("<aaa abc>", "<aaa abc>"),
153 |         ("<aaa abc", "<aaa abc="),
154 |         ("<aaa abc", "<aaa abc "),
155 |     ];
156 | 
157 |     test_enabled_all_options(&CASES);
158 | }
159 | 
160 | #[test]
161 | fn start_tag_attribute_name_waiting_value() {
162 |     const CASES: [(&str, &str); 6] = [
163 |         ("<aaa abc/", "<aaa abc /"),
164 |         ("<aaa abc/", "<aaa abc   /"),
165 |         ("<aaa abc>", "<aaa abc >"),
166 |         ("<aaa abc>", "<aaa abc   >"),
167 |         ("<aaa abc", "<aaa abc ="),
168 |         ("<aaa abc", "<aaa abc   ="),
169 |     ];
170 | 
171 |     test_enabled_all_options(&CASES);
172 | }
173 | 
174 | #[test]
175 | fn start_tag_attribute_value_initial() {
176 |     const CASES: [(&str, &str); 7] = [
177 |         ("<aaa abc/", "<aaa abc=/"),
178 |         ("<aaa abc>", "<aaa abc=>"),
179 |         ("<aaa abc", "<aaa abc=\""),
180 |         ("<aaa abc", "<aaa abc='"),
181 |         ("<aaa abc", "<aaa abc= '"),
182 |         ("<aaa abc", "<aaa abc= "),
183 |         ("<aaa abc=v", "<aaa abc=v"),
184 |     ];
185 | 
186 |     test_enabled_all_options(&CASES);
187 | }
188 | 
189 | #[test]
190 | fn start_tag_quoted_attribute_value() {
191 |     const CASES: [(&str, &str); 10] = [
192 |         ("<aaa abc=\"v", "<aaa abc=\"v"),
193 |         ("<aaa abc='v", "<aaa abc='v"),
194 |         ("<aaa abc='123   456'", "<aaa abc='123   456'"),
195 |         ("<aaa class='123 456'", "<aaa class='  123   456  '"),
196 |         ("<aaa type='123   456'", "<aaa type='123   456'"),
197 |         ("<style type='123 456'", "<style type='  123   456  '"),
198 |         ("<script type='123 456'", "<script type='  123   456  '"),
199 |         ("<aaa abc", "<aaa abc=''"),
200 |         ("<aaa class", "<aaa class=''"),
201 |         ("<aaa class", "<aaa class=' '"),
202 |     ];
203 | 
204 |     test_enabled_all_options(&CASES);
205 | }
206 | 
207 | #[test]
208 | fn start_tag_unquoted_attribute_value() {
209 |     const CASES: [(&str, &str); 3] = [
210 |         ("<aaa abc=vv", "<aaa abc=vv"),
211 |         ("<aaa abc=vv>", "<aaa abc=vv>"),
212 |         ("<aaa abc=vv", "<aaa abc=vv "),
213 |     ];
214 | 
215 |     test_enabled_all_options(&CASES);
216 | }
217 | 
218 | #[test]
219 | fn end_tag() {
220 |     const CASES: [(&str, &str); 3] = [("</aaa", "</aaa"), ("</aaa", "</aaa"), ("</aaa>", "</aaa>")];
221 | 
222 |     test_enabled_all_options(&CASES);
223 | }
224 | 
225 | #[test]
226 | fn tag_end() {
227 |     const CASES: [(&str, &str); 4] = [
228 |         ("<aaa/", "<aaa/123"),
229 |         ("<aaa/>", "<aaa/>"),
230 |         ("</aaa", "</aaa 123"),
231 |         ("</aaa>", "</aaa 123>"),
232 |     ];
233 | 
234 |     test_enabled_all_options(&CASES);
235 | }
236 | 
237 | #[test]
238 | fn doctype() {
239 |     const CASES: [(&str, &str); 5] = [
240 |         ("<!aaa", "<!aaa"),
241 |         ("<!aaa   ", "<!aaa   "),
242 |         ("<!aaa>", "<!aaa>"),
243 |         ("<!aaa   >", "<!aaa   >"),
244 |         ("", "<!--"),
245 |     ];
246 | 
247 |     test_enabled_all_options(&CASES);
248 | }
249 | 
250 | #[test]
251 | fn comment() {
252 |     const CASES: [(&str, &str); 2] = [("123", "1<!---->23"), ("", "<!--123-->")];
253 | 
254 |     test_enabled_all_options(&CASES);
255 | 
256 |     const CASES2: [(&str, &str); 2] = [("1<!---->23", "1<!---->23"), ("<!--123-->", "<!--123-->")];
257 | 
258 |     test_disabled_all_options(&CASES2);
259 | }
260 | 
261 | #[test]
262 | fn script_default() {
263 |     const CASES: [(&str, &str); 2] = [
264 |         (
265 |             "<script type='application/ecmascript'>   alert('1234!')    ;   </script>",
266 |             "<script type='application/ecmascript'>   alert('1234!')    ;   </script>",
267 |         ),
268 |         (
269 |             "<script type='application/ecmascript'>   alert('1234!')    ;   </script>",
270 |             "<script type='application/ecmascript'>   alert('1234!')    ;   </script  >",
271 |         ),
272 |     ];
273 | 
274 |     test_enabled_all_options(&CASES);
275 | }
276 | 
277 | #[test]
278 | fn script_javascript() {
279 |     const CASES: [(&str, &str); 3] = [
280 |         (
281 |             "<script type='application/javascript'>alert('1234!')</script>",
282 |             "<script type='application/javascript'>   alert('1234!')    ;   </script>",
283 |         ),
284 |         ("<script>alert('1234!')</script>", "<script>   alert('1234!')    ;   </script  >"),
285 |         ("<script>alert('1234!')</script>", "<script>alert('1234!');</script>"),
286 |     ];
287 | 
288 |     test_enabled_all_options(&CASES);
289 | }
290 | 
291 | #[test]
292 | fn style_default() {
293 |     const CASES: [(&str, &str); 2] = [
294 |         (
295 |             "<style type='text/x-scss'>
296 | h1 {
297 |     color: blue;
298 |     font-family: verdana;
299 |     font-size: 300%;
300 | }
301 | </style>",
302 |             "<style type='text/x-scss'>
303 | h1 {
304 |     color: blue;
305 |     font-family: verdana;
306 |     font-size: 300%;
307 | }
308 | </style>",
309 |         ),
310 |         (
311 |             "<style type='text/x-scss'>
312 | h1 {
313 |     color: blue;
314 |     font-family: verdana;
315 |     font-size: 300%;
316 | }
317 | </style>",
318 |             "<style type='text/x-scss'>
319 | h1 {
320 |     color: blue;
321 |     font-family: verdana;
322 |     font-size: 300%;
323 | }
324 | </style  >",
325 |         ),
326 |     ];
327 | 
328 |     test_enabled_all_options(&CASES);
329 | }
330 | 
331 | #[test]
332 | fn style_css() {
333 |     const CASES: [(&str, &str); 3] = [
334 |         (
335 |             "<style type='text/css'>h1{color:blue;font-family:verdana;font-size:300%;}</style>",
336 |             "<style type='text/css'>
337 | h1 {
338 |     color: blue;
339 |     font-family: verdana;
340 |     font-size: 300%;
341 | }
342 | </style>",
343 |         ),
344 |         (
345 |             "<style>h1{color:blue;font-family:verdana;font-size:300%;}</style>",
346 |             "<style>
347 | h1 {
348 |     color: blue;
349 |     font-family: verdana;
350 |     font-size: 300%;
351 | }
352 | </style  >",
353 |         ),
354 |         (
355 |             "<style>h1{color:blue;font-family:verdana;font-size:300%;}</style>",
356 |             "<style>h1{color:blue;font-family:verdana;font-size:300%;}</style>",
357 |         ),
358 |     ];
359 | 
360 |     test_enabled_all_options(&CASES);
361 | }
362 | 
363 | #[test]
364 | fn pre() {
365 |     const CASES: [(&str, &str); 2] = [
366 |         ("<pre>   alert('1234!')    ;   </pre>", "<pre>   alert('1234!')    ;   </pre>"),
367 |         ("<pre>   alert('1234!')    ;   </pre>", "<pre>   alert('1234!')    ;   </pre  >"),
368 |     ];
369 | 
370 |     test_enabled_all_options(&CASES);
371 | }
372 | 
373 | #[test]
374 | fn code() {
375 |     const CASES: [(&str, &str); 2] = [
376 |         ("<code> alert('1234!') ; </code>", "<code>   alert('1234!')    ;   </code>"),
377 |         ("<code> alert('1234!') ; </code>", "<code>   alert('1234!')    ;   </code  >"),
378 |     ];
379 | 
380 |     test_enabled_all_options(&CASES);
381 | 
382 |     const CASES2: [(&str, &str); 2] = [
383 |         ("<code>   alert('1234!')    ;   </code>", "<code>   alert('1234!')    ;   </code>"),
384 |         ("<code>   alert('1234!')    ;   </code>", "<code>   alert('1234!')    ;   </code  >"),
385 |     ];
386 | 
387 |     test_disabled_all_options(&CASES2);
388 | }
389 | 
390 | #[test]
391 | fn textarea() {
392 |     const CASES: [(&str, &str); 2] = [
393 |         (
394 |             "<textarea>   alert('1234!')    ;   </textarea>",
395 |             "<textarea>   alert('1234!')    ;   </textarea>",
396 |         ),
397 |         (
398 |             "<textarea>   alert('1234!')    ;   </textarea>",
399 |             "<textarea>   alert('1234!')    ;   </textarea  >",
400 |         ),
401 |     ];
402 | 
403 |     test_enabled_all_options(&CASES);
404 | }
405 | 
406 | // TODO -----Width 2-----
407 | 
408 | #[test]
409 | fn width_2_initial() {
410 |     const CASES: [(&str, &str); 1] = [("é", "  é")];
411 | 
412 |     test_enabled_all_options(&CASES);
413 | }
414 | 
415 | #[test]
416 | fn width_2_initial_remain_one_whitespace() {
417 |     const CASES: [(&str, &str); 2] = [("é", "é "), ("é", "é\t")];
418 | 
419 |     test_enabled_all_options(&CASES);
420 | }
421 | 
422 | #[test]
423 | fn width_2_initial_ignore_whitespace() {
424 |     const CASES: [(&str, &str); 2] = [("é éé", "é  éé"), ("é ééé ééé", "é  ééé   ééé")];
425 | 
426 |     test_enabled_all_options(&CASES);
427 | }
428 | 
429 | #[test]
430 | fn width_2_start_tag_initial() {
431 |     const CASES: [(&str, &str); 1] = [("<é >", "<é >")];
432 | 
433 |     test_enabled_all_options(&CASES);
434 | }
435 | 
436 | #[test]
437 | fn width_2_end_tag_initial() {
438 |     const CASES: [(&str, &str); 1] = [("</é >", "</é >")];
439 | 
440 |     test_enabled_all_options(&CASES);
441 | }
442 | 
443 | #[test]
444 | fn width_2_start_tag() {
445 |     const CASES: [(&str, &str); 1] = [("<aé >", "<aé >")];
446 | 
447 |     test_enabled_all_options(&CASES);
448 | }
449 | 
450 | #[test]
451 | fn width_2_end_tag() {
452 |     const CASES: [(&str, &str); 1] = [("</aé >", "</aé >")];
453 | 
454 |     test_enabled_all_options(&CASES);
455 | }
456 | 
457 | #[test]
458 | fn width_2_start_tag_in() {
459 |     const CASES: [(&str, &str); 1] = [("<a é>", "<a é >")];
460 | 
461 |     test_enabled_all_options(&CASES);
462 | }
463 | 
464 | #[test]
465 | fn width_2_start_tag_attribute_name() {
466 |     const CASES: [(&str, &str); 1] = [("<a ééé>", "<a ééé >")];
467 | 
468 |     test_enabled_all_options(&CASES);
469 | }
470 | 
471 | #[test]
472 | fn width_2_start_tag_attribute_name_waiting_value() {
473 |     const CASES: [(&str, &str); 1] = [("<a a é>", "<a a é >")];
474 | 
475 |     test_enabled_all_options(&CASES);
476 | }
477 | 
478 | #[test]
479 | fn width_2_start_tag_attribute_value_initial() {
480 |     const CASES: [(&str, &str); 1] = [("<a é=é>", "<a é=é>")];
481 | 
482 |     test_enabled_all_options(&CASES);
483 | }
484 | 
485 | #[test]
486 | fn width_2_start_tag_quoted_attribute_value() {
487 |     const CASES: [(&str, &str); 1] = [("<a é='ééé é'>", "<a é='ééé é' >")];
488 | 
489 |     test_enabled_all_options(&CASES);
490 | }
491 | 
492 | #[test]
493 | fn width_2_start_tag_unquoted_attribute_value() {
494 |     const CASES: [(&str, &str); 1] = [("<a é=ééé>", "<a é=ééé >")];
495 | 
496 |     test_enabled_all_options(&CASES);
497 | }
498 | 
499 | #[test]
500 | fn width_2_tag_end() {
501 |     const CASES: [(&str, &str); 3] =
502 |         [("<aaa/", "<aaa/ééé"), ("</aaa", "</aaa ééé"), ("</aaa>", "</aaa ééé>")];
503 | 
504 |     test_enabled_all_options(&CASES);
505 | }
506 | 
507 | #[test]
508 | fn width_2_doctype() {
509 |     const CASES: [(&str, &str); 1] = [("<!ééé", "<!ééé")];
510 | 
511 |     test_enabled_all_options(&CASES);
512 | }
513 | 
514 | #[test]
515 | fn width_2_comment() {
516 |     const CASES: [(&str, &str); 2] = [("ééé", "é<!---->éé"), ("", "<!--ééé-->")];
517 | 
518 |     test_enabled_all_options(&CASES);
519 | 
520 |     const CASES2: [(&str, &str); 2] = [("é<!---->éé", "é<!---->éé"), ("<!--ééé-->", "<!--ééé-->")];
521 | 
522 |     test_disabled_all_options(&CASES2);
523 | }
524 | 
525 | #[test]
526 | fn width_2_script_default() {
527 |     const CASES: [(&str, &str); 2] = [
528 |         (
529 |             "<script type='application/ecmascript'>   é é   </script>",
530 |             "<script type='application/ecmascript'>   é é   </script>",
531 |         ),
532 |         (
533 |             "<script type='application/ecmascript'>   é é   </script>",
534 |             "<script type='application/ecmascript'>   é é   </script  >",
535 |         ),
536 |     ];
537 | 
538 |     test_enabled_all_options(&CASES);
539 | }
540 | 
541 | #[test]
542 | fn width_2_script_javascript() {
543 |     const CASES: [(&str, &str); 3] = [
544 |         (
545 |             "<script type='application/javascript'>alert('ééé!')</script>",
546 |             "<script type='application/javascript'>   alert('ééé!')    ;   </script>",
547 |         ),
548 |         ("<script>alert('ééé!')</script>", "<script>   alert('ééé!')    ;   </script  >"),
549 |         ("<script>alert('ééé!')</script>", "<script>alert('ééé!');</script>"),
550 |     ];
551 | 
552 |     test_enabled_all_options(&CASES);
553 | }
554 | 
555 | // TODO -----Width n (3 & 4)-----
556 | 
557 | #[test]
558 | fn width_n_initial() {
559 |     const CASES: [(&str, &str); 1] = [("中", "  中")];
560 | 
561 |     test_enabled_all_options(&CASES);
562 | }
563 | 
564 | #[test]
565 | fn width_n_initial_remain_one_whitespace() {
566 |     const CASES: [(&str, &str); 2] = [("中", "中 "), ("中", "中\t")];
567 | 
568 |     test_enabled_all_options(&CASES);
569 | }
570 | 
571 | #[test]
572 | fn width_n_initial_ignore_whitespace() {
573 |     const CASES: [(&str, &str); 14] = [
574 |         ("中 中中", "中  中中"),
575 |         ("中 中中中 中中中", "中  中中中   中中中"),
576 |         ("中\n中", "中\n\t 中"),
577 |         ("中\n中", "中 \n\t 中"),
578 |         ("中\na", "中\n\t a"),
579 |         ("中\na", "中 \n\t a"),
580 |         ("a\n中", "a\n\t 中"),
581 |         ("a\n中", "a \n\t 中"),
582 |         ("中 中", "中\t 中"),
583 |         ("中 中", "中 \t 中"),
584 |         ("中 a", "中\t a"),
585 |         ("中 a", "中 \t a"),
586 |         ("a 中", "a\t 中"),
587 |         ("a 中", "a \t 中"),
588 |     ];
589 | 
590 |     test_enabled_all_options(&CASES);
591 | }
592 | 
593 | #[test]
594 | fn width_n_start_tag_initial() {
595 |     const CASES: [(&str, &str); 1] = [("<中 >", "<中 >")];
596 | 
597 |     test_enabled_all_options(&CASES);
598 | }
599 | 
600 | #[test]
601 | fn width_n_end_tag_initial() {
602 |     const CASES: [(&str, &str); 1] = [("</中 >", "</中 >")];
603 | 
604 |     test_enabled_all_options(&CASES);
605 | }
606 | 
607 | #[test]
608 | fn width_n_start_tag() {
609 |     const CASES: [(&str, &str); 1] = [("<a中 >", "<a中 >")];
610 | 
611 |     test_enabled_all_options(&CASES);
612 | }
613 | 
614 | #[test]
615 | fn width_n_end_tag() {
616 |     const CASES: [(&str, &str); 1] = [("</a中 >", "</a中 >")];
617 | 
618 |     test_enabled_all_options(&CASES);
619 | }
620 | 
621 | #[test]
622 | fn width_n_start_tag_in() {
623 |     const CASES: [(&str, &str); 1] = [("<a 中>", "<a 中 >")];
624 | 
625 |     test_enabled_all_options(&CASES);
626 | }
627 | 
628 | #[test]
629 | fn width_n_start_tag_attribute_name() {
630 |     const CASES: [(&str, &str); 1] = [("<a 中中中>", "<a 中中中 >")];
631 | 
632 |     test_enabled_all_options(&CASES);
633 | }
634 | 
635 | #[test]
636 | fn width_n_start_tag_attribute_name_waiting_value() {
637 |     const CASES: [(&str, &str); 1] = [("<a a 中>", "<a a 中 >")];
638 | 
639 |     test_enabled_all_options(&CASES);
640 | }
641 | 
642 | #[test]
643 | fn width_n_start_tag_attribute_value_initial() {
644 |     const CASES: [(&str, &str); 1] = [("<a 中=中>", "<a 中=中>")];
645 | 
646 |     test_enabled_all_options(&CASES);
647 | }
648 | 
649 | #[test]
650 | fn width_n_start_tag_quoted_attribute_value() {
651 |     const CASES: [(&str, &str); 1] = [("<a 中='中中中 中'>", "<a 中='中中中 中' >")];
652 | 
653 |     test_enabled_all_options(&CASES);
654 | }
655 | 
656 | #[test]
657 | fn width_n_start_tag_unquoted_attribute_value() {
658 |     const CASES: [(&str, &str); 1] = [("<a 中=中中中>", "<a 中=中中中 >")];
659 | 
660 |     test_enabled_all_options(&CASES);
661 | }
662 | 
663 | #[test]
664 | fn width_n_tag_end() {
665 |     const CASES: [(&str, &str); 3] =
666 |         [("<aaa/", "<aaa/中中中"), ("</aaa", "</aaa 中中中"), ("</aaa>", "</aaa 中中中>")];
667 | 
668 |     test_enabled_all_options(&CASES);
669 | }
670 | 
671 | #[test]
672 | fn width_n_doctype() {
673 |     const CASES: [(&str, &str); 1] = [("<!中中中", "<!中中中")];
674 | 
675 |     test_enabled_all_options(&CASES);
676 | }
677 | 
678 | #[test]
679 | fn width_n_comment() {
680 |     const CASES: [(&str, &str); 2] = [("中中中", "中<!---->中中"), ("", "<!--中中中-->")];
681 | 
682 |     test_enabled_all_options(&CASES);
683 | 
684 |     const CASES2: [(&str, &str); 2] =
685 |         [("中<!---->中中", "中<!---->中中"), ("<!--中中中-->", "<!--中中中-->")];
686 | 
687 |     test_disabled_all_options(&CASES2);
688 | }
689 | 
690 | #[test]
691 | fn width_n_script_default() {
692 |     const CASES: [(&str, &str); 2] = [
693 |         (
694 |             "<script type='application/ecmascript'>   中 中   </script>",
695 |             "<script type='application/ecmascript'>   中 中   </script>",
696 |         ),
697 |         (
698 |             "<script type='application/ecmascript'>   中 中   </script>",
699 |             "<script type='application/ecmascript'>   中 中   </script  >",
700 |         ),
701 |     ];
702 | 
703 |     test_enabled_all_options(&CASES);
704 | }
705 | 
706 | #[test]
707 | fn width_n_script_javascript() {
708 |     const CASES: [(&str, &str); 3] = [
709 |         (
710 |             "<script type='application/javascript'>alert('中中中!')</script>",
711 |             "<script type='application/javascript'>   alert('中中中!')    ;   </script>",
712 |         ),
713 |         ("<script>alert('中中中!')</script>", "<script>   alert('中中中!')    ;   </script  >"),
714 |         ("<script>alert('中中中!')</script>", "<script>alert('中中中!');</script>"),
715 |     ];
716 | 
717 |     test_enabled_all_options(&CASES);
718 | }
719 | 


--------------------------------------------------------------------------------
/src/html_minifier_helper.rs:
--------------------------------------------------------------------------------
   1 | use std::{borrow::Cow, str::from_utf8_unchecked};
   2 | 
   3 | use cow_utils::CowUtils;
   4 | use educe::Educe;
   5 | pub use minifier::{css, js};
   6 | 
   7 | use crate::{functions::*, HTMLMinifierError, HTMLWriter};
   8 | 
   9 | #[derive(Educe, Debug, Copy, Clone, Eq, PartialEq)]
  10 | #[educe(Default)]
  11 | enum Step {
  12 |     #[educe(Default)]
  13 |     Initial,
  14 |     InitialRemainOneWhitespace,
  15 |     InitialIgnoreWhitespace,
  16 |     StartTagInitial,
  17 |     EndTagInitial,
  18 |     StartTag,
  19 |     StartTagIn,
  20 |     StartTagAttributeName,
  21 |     StartTagAttributeNameWaitingValue,
  22 |     StartTagAttributeValueInitial,
  23 |     StartTagUnquotedAttributeValue,
  24 |     StartTagQuotedAttributeValue,
  25 |     EndTag,
  26 |     TagEnd,
  27 |     Doctype,
  28 |     Comment,
  29 |     ScriptDefault,
  30 |     ScriptJavaScript,
  31 |     StyleDefault,
  32 |     StyleCSS,
  33 |     Pre,
  34 |     Code,
  35 |     Textarea,
  36 | }
  37 | 
  38 | /// This struct helps you generate and minify your HTML code in the same time. The output destination is outside this struct.
  39 | #[derive(Educe, Clone)]
  40 | #[educe(Debug, Default(new))]
  41 | pub struct HTMLMinifierHelper {
  42 |     #[educe(Default = true)]
  43 |     /// Remove HTML comments.
  44 |     pub remove_comments: bool,
  45 |     #[educe(Default = true)]
  46 |     /// Minify the content in the `code` element.
  47 |     pub minify_code:     bool,
  48 | 
  49 |     // Buffers
  50 |     #[educe(Debug(method = "str_bytes_fmt"))]
  51 |     buffer:         Vec<u8>,
  52 |     #[educe(Debug(method = "str_bytes_fmt"))]
  53 |     tag:            Vec<u8>,
  54 |     #[educe(Debug(method = "str_bytes_fmt"))]
  55 |     attribute_type: Vec<u8>,
  56 | 
  57 |     // Steps
  58 |     step:         Step,
  59 |     step_counter: u8,
  60 | 
  61 |     // Temp
  62 |     quote:      u8,
  63 |     last_space: u8,
  64 | 
  65 |     // Flags
  66 |     quoted_value_spacing: bool,
  67 |     quoted_value_empty:   bool,
  68 |     in_handled_attribute: bool,
  69 |     in_attribute_type:    bool,
  70 | }
  71 | 
  72 | impl HTMLMinifierHelper {
  73 |     #[inline]
  74 |     fn set_flags_by_attribute(&mut self) {
  75 |         match self.buffer.as_slice() {
  76 |             b"class" => {
  77 |                 self.in_handled_attribute = true;
  78 |                 self.in_attribute_type = false;
  79 |             },
  80 |             b"type" => match self.tag.as_slice() {
  81 |                 b"script" | b"style" => {
  82 |                     self.in_handled_attribute = true;
  83 |                     self.in_attribute_type = true;
  84 |                 },
  85 |                 _ => (),
  86 |             },
  87 |             _ => {
  88 |                 self.in_handled_attribute = false;
  89 |                 self.in_attribute_type = false;
  90 |             },
  91 |         }
  92 |     }
  93 | 
  94 |     #[inline]
  95 |     fn finish_buffer(&mut self) {
  96 |         if self.in_attribute_type {
  97 |             if let Cow::Owned(attribute_value) = html_escape::decode_html_entities(unsafe {
  98 |                 from_utf8_unchecked(&self.attribute_type)
  99 |             }) {
 100 |                 self.attribute_type = attribute_value.into_bytes();
 101 |             }
 102 | 
 103 |             if let Cow::Owned(attribute_value) =
 104 |                 unsafe { from_utf8_unchecked(&self.attribute_type) }.cow_to_ascii_lowercase()
 105 |             {
 106 |                 self.attribute_type = attribute_value.into_bytes();
 107 |             }
 108 |         }
 109 |     }
 110 | 
 111 |     #[inline]
 112 |     fn end_start_tag_and_get_next_step(
 113 |         &mut self,
 114 |         out: &mut impl HTMLWriter,
 115 |         text_bytes: &[u8],
 116 |         start: &mut usize,
 117 |         p: usize,
 118 |     ) -> Result<Step, HTMLMinifierError> {
 119 |         let step = match self.tag.as_slice() {
 120 |             b"script" => {
 121 |                 self.step_counter = 0;
 122 | 
 123 |                 match self.attribute_type.as_slice() {
 124 |                     b"" | b"application/javascript" | b"module" => {
 125 |                         out.push_bytes(&text_bytes[*start..=p])?;
 126 |                         *start = p + 1;
 127 | 
 128 |                         self.attribute_type.clear();
 129 |                         self.buffer.clear();
 130 | 
 131 |                         Step::ScriptJavaScript
 132 |                     },
 133 |                     _ => {
 134 |                         self.attribute_type.clear();
 135 | 
 136 |                         Step::ScriptDefault
 137 |                     },
 138 |                 }
 139 |             },
 140 |             b"style" => {
 141 |                 self.step_counter = 0;
 142 | 
 143 |                 match self.attribute_type.as_slice() {
 144 |                     b"" | b"text/css" => {
 145 |                         out.push_bytes(&text_bytes[*start..=p])?;
 146 |                         *start = p + 1;
 147 | 
 148 |                         self.attribute_type.clear();
 149 |                         self.buffer.clear();
 150 | 
 151 |                         Step::StyleCSS
 152 |                     },
 153 |                     _ => {
 154 |                         self.attribute_type.clear();
 155 | 
 156 |                         Step::StyleDefault
 157 |                     },
 158 |                 }
 159 |             },
 160 |             b"pre" => {
 161 |                 self.step_counter = 0;
 162 |                 Step::Pre
 163 |             },
 164 |             b"code" => {
 165 |                 if self.minify_code {
 166 |                     self.last_space = 0;
 167 | 
 168 |                     Step::InitialRemainOneWhitespace
 169 |                 } else {
 170 |                     self.step_counter = 0;
 171 |                     Step::Code
 172 |                 }
 173 |             },
 174 |             b"textarea" => {
 175 |                 self.step_counter = 0;
 176 |                 Step::Textarea
 177 |             },
 178 |             _ => {
 179 |                 self.last_space = 0;
 180 | 
 181 |                 Step::InitialRemainOneWhitespace
 182 |             },
 183 |         };
 184 | 
 185 |         Ok(step)
 186 |     }
 187 | }
 188 | 
 189 | impl HTMLMinifierHelper {
 190 |     /// Reset this html minifier helper. The option settings and allocated memory will be be preserved.
 191 |     #[inline]
 192 |     pub fn reset(&mut self) {
 193 |         self.step = Step::default();
 194 | 
 195 |         self.attribute_type.clear();
 196 |     }
 197 | 
 198 |     /// Input some text to generate HTML code. It is not necessary to input a full HTML text at once.
 199 |     pub fn digest<S: AsRef<[u8]>, W: HTMLWriter>(
 200 |         &mut self,
 201 |         text: S,
 202 |         out: &mut W,
 203 |     ) -> Result<(), HTMLMinifierError> {
 204 |         let text_bytes = text.as_ref();
 205 |         let text_length = text_bytes.len();
 206 | 
 207 |         let mut start = 0;
 208 |         let mut p = 0;
 209 | 
 210 |         while p < text_length {
 211 |             let e = text_bytes[p];
 212 | 
 213 |             if e <= 0x7F {
 214 |                 // ASCII
 215 |                 if is_ascii_control(e) {
 216 |                     out.push_bytes(&text_bytes[start..p])?;
 217 |                     start = p + 1;
 218 |                 } else {
 219 |                     match self.step {
 220 |                         Step::Initial => {
 221 |                             // ?
 222 |                             match e {
 223 |                                 b'<' => {
 224 |                                     out.push_bytes(&text_bytes[start..p])?;
 225 |                                     start = p + 1;
 226 | 
 227 |                                     self.step = Step::StartTagInitial;
 228 |                                 },
 229 |                                 _ => {
 230 |                                     if is_whitespace(e) {
 231 |                                         debug_assert_eq!(start, p);
 232 |                                         start = p + 1;
 233 |                                     } else {
 234 |                                         self.last_space = 0;
 235 |                                         self.step = Step::InitialRemainOneWhitespace;
 236 |                                     }
 237 |                                 },
 238 |                             }
 239 |                         },
 240 |                         Step::InitialRemainOneWhitespace => {
 241 |                             // a?
 242 |                             if is_whitespace(e) {
 243 |                                 out.push_bytes(&text_bytes[start..p])?;
 244 |                                 start = p + 1;
 245 | 
 246 |                                 self.last_space = e;
 247 | 
 248 |                                 self.step = Step::InitialIgnoreWhitespace;
 249 |                             } else if e == b'<' {
 250 |                                 out.push_bytes(&text_bytes[start..p])?;
 251 |                                 start = p + 1;
 252 | 
 253 |                                 self.step = Step::StartTagInitial;
 254 |                             } else {
 255 |                                 self.last_space = 0;
 256 |                             }
 257 |                         },
 258 |                         Step::InitialIgnoreWhitespace => {
 259 |                             // a ?
 260 |                             match e {
 261 |                                 b'\n' => {
 262 |                                     debug_assert_eq!(start, p);
 263 |                                     start = p + 1;
 264 | 
 265 |                                     if self.last_space > 0 {
 266 |                                         self.last_space = b'\n';
 267 |                                     }
 268 |                                 },
 269 |                                 0x09 | 0x0B..=0x0D | 0x1C..=0x20 => {
 270 |                                     debug_assert_eq!(start, p);
 271 |                                     start = p + 1;
 272 |                                 },
 273 |                                 b'<' => {
 274 |                                     // This can just push ' ', but the minified HTML would be ugly
 275 |                                     if self.last_space == b'\n' {
 276 |                                         out.push(b'\n')?;
 277 |                                     } else if self.last_space > 0 {
 278 |                                         out.push(b' ')?;
 279 |                                     }
 280 | 
 281 |                                     out.push_bytes(&text_bytes[start..p])?;
 282 |                                     start = p + 1;
 283 | 
 284 |                                     self.step = Step::StartTagInitial;
 285 |                                 },
 286 |                                 _ => {
 287 |                                     if self.last_space == b'\n' {
 288 |                                         out.push(b'\n')?;
 289 |                                     } else if self.last_space > 0 {
 290 |                                         out.push(b' ')?;
 291 |                                     }
 292 | 
 293 |                                     self.last_space = 0;
 294 |                                     self.step = Step::InitialRemainOneWhitespace;
 295 |                                 },
 296 |                             }
 297 |                         },
 298 |                         Step::StartTagInitial => {
 299 |                             debug_assert_eq!(start, p);
 300 | 
 301 |                             // <?
 302 |                             match e {
 303 |                                 b'/' => {
 304 |                                     start = p + 1;
 305 | 
 306 |                                     self.step = Step::EndTagInitial;
 307 |                                 },
 308 |                                 b'!' => {
 309 |                                     // <!
 310 |                                     start = p + 1;
 311 | 
 312 |                                     self.step_counter = 0;
 313 |                                     self.step = Step::Doctype;
 314 |                                 },
 315 |                                 b'>' => {
 316 |                                     // <>
 317 |                                     start = p + 1;
 318 | 
 319 |                                     self.last_space = 0;
 320 |                                     self.step = Step::InitialRemainOneWhitespace;
 321 |                                 },
 322 |                                 _ => {
 323 |                                     out.push(b'<')?;
 324 | 
 325 |                                     if is_whitespace(e) {
 326 |                                         out.push_bytes(&text_bytes[start..p])?;
 327 |                                         start = p + 1;
 328 | 
 329 |                                         self.last_space = e;
 330 | 
 331 |                                         self.step = Step::InitialIgnoreWhitespace;
 332 |                                     } else {
 333 |                                         self.tag.clear();
 334 |                                         self.tag.push(e.to_ascii_lowercase());
 335 | 
 336 |                                         self.step = Step::StartTag;
 337 |                                     }
 338 |                                 },
 339 |                             }
 340 |                         },
 341 |                         Step::EndTagInitial => {
 342 |                             // </?
 343 |                             match e {
 344 |                                 b'>' => {
 345 |                                     // </>
 346 |                                     start = p + 1;
 347 | 
 348 |                                     self.last_space = 0;
 349 |                                     self.step = Step::InitialRemainOneWhitespace;
 350 |                                 },
 351 |                                 _ => {
 352 |                                     out.push_bytes(b"</")?;
 353 | 
 354 |                                     if is_whitespace(e) {
 355 |                                         start = p + 1;
 356 | 
 357 |                                         self.last_space = e;
 358 | 
 359 |                                         self.step = Step::InitialIgnoreWhitespace;
 360 |                                     } else {
 361 |                                         self.step = Step::EndTag;
 362 |                                     }
 363 |                                 },
 364 |                             }
 365 |                         },
 366 |                         Step::StartTag => {
 367 |                             // <a?
 368 |                             if is_whitespace(e) {
 369 |                                 out.push_bytes(&text_bytes[start..p])?;
 370 |                                 start = p + 1;
 371 | 
 372 |                                 self.buffer.clear(); // the buffer may be used for the `type` attribute
 373 | 
 374 |                                 self.last_space = 0;
 375 |                                 self.step = Step::StartTagIn;
 376 |                             } else {
 377 |                                 match e {
 378 |                                     b'/' => self.step = Step::TagEnd,
 379 |                                     b'>' => {
 380 |                                         self.buffer.clear(); // the buffer may be used for the `type` attribute
 381 | 
 382 |                                         self.step = self.end_start_tag_and_get_next_step(
 383 |                                             out, text_bytes, &mut start, p,
 384 |                                         )?;
 385 |                                     },
 386 |                                     _ => self.tag.push(e.to_ascii_lowercase()),
 387 |                                 }
 388 |                             }
 389 |                         },
 390 |                         Step::StartTagIn => {
 391 |                             // <a ?
 392 |                             match e {
 393 |                                 b'/' => {
 394 |                                     if self.last_space > 0 {
 395 |                                         out.push(b' ')?;
 396 |                                     }
 397 | 
 398 |                                     self.step = Step::TagEnd;
 399 |                                 },
 400 |                                 b'>' => {
 401 |                                     self.step = self.end_start_tag_and_get_next_step(
 402 |                                         out, text_bytes, &mut start, p,
 403 |                                     )?;
 404 |                                 },
 405 |                                 _ => {
 406 |                                     if is_whitespace(e) {
 407 |                                         debug_assert_eq!(start, p);
 408 |                                         start = p + 1;
 409 |                                     } else {
 410 |                                         out.push(b' ')?;
 411 | 
 412 |                                         self.buffer.clear();
 413 |                                         self.buffer.push(e.to_ascii_lowercase());
 414 | 
 415 |                                         self.step = Step::StartTagAttributeName;
 416 |                                     }
 417 |                                 },
 418 |                             }
 419 |                         },
 420 |                         Step::StartTagAttributeName => {
 421 |                             // <a a?
 422 |                             match e {
 423 |                                 b'/' => self.step = Step::TagEnd,
 424 |                                 b'>' => {
 425 |                                     self.step = self.end_start_tag_and_get_next_step(
 426 |                                         out, text_bytes, &mut start, p,
 427 |                                     )?;
 428 |                                 },
 429 |                                 b'=' => {
 430 |                                     out.push_bytes(&text_bytes[start..p])?;
 431 |                                     start = p + 1;
 432 | 
 433 |                                     self.set_flags_by_attribute();
 434 | 
 435 |                                     self.step = Step::StartTagAttributeValueInitial;
 436 |                                 },
 437 |                                 _ => {
 438 |                                     if is_whitespace(e) {
 439 |                                         out.push_bytes(&text_bytes[start..p])?;
 440 |                                         start = p + 1;
 441 | 
 442 |                                         self.step = Step::StartTagAttributeNameWaitingValue;
 443 |                                     } else {
 444 |                                         self.buffer.push(e.to_ascii_lowercase());
 445 |                                     }
 446 |                                 },
 447 |                             }
 448 |                         },
 449 |                         Step::StartTagAttributeNameWaitingValue => {
 450 |                             // <a a ?
 451 |                             match e {
 452 |                                 b'/' => self.step = Step::TagEnd,
 453 |                                 b'>' => {
 454 |                                     self.step = self.end_start_tag_and_get_next_step(
 455 |                                         out, text_bytes, &mut start, p,
 456 |                                     )?;
 457 |                                 },
 458 |                                 b'=' => {
 459 |                                     out.push_bytes(&text_bytes[start..p])?;
 460 |                                     start = p + 1;
 461 | 
 462 |                                     self.set_flags_by_attribute();
 463 | 
 464 |                                     self.step = Step::StartTagAttributeValueInitial;
 465 |                                 },
 466 |                                 _ => {
 467 |                                     if is_whitespace(e) {
 468 |                                         debug_assert_eq!(start, p);
 469 |                                         start = p + 1;
 470 |                                     } else {
 471 |                                         out.push(b' ')?;
 472 | 
 473 |                                         self.buffer.clear();
 474 |                                         self.buffer.push(e.to_ascii_lowercase());
 475 | 
 476 |                                         self.step = Step::StartTagAttributeName;
 477 |                                     }
 478 |                                 },
 479 |                             }
 480 |                         },
 481 |                         Step::StartTagAttributeValueInitial => {
 482 |                             // <a a=?
 483 |                             debug_assert_eq!(start, p);
 484 | 
 485 |                             match e {
 486 |                                 b'/' => {
 487 |                                     self.step = Step::TagEnd;
 488 |                                 },
 489 |                                 b'>' => {
 490 |                                     self.step = self.end_start_tag_and_get_next_step(
 491 |                                         out, text_bytes, &mut start, p,
 492 |                                     )?;
 493 |                                 },
 494 |                                 b'"' | b'\'' => {
 495 |                                     self.quoted_value_spacing = false;
 496 |                                     self.quoted_value_empty = true;
 497 | 
 498 |                                     start = p + 1;
 499 | 
 500 |                                     self.quote = e;
 501 |                                     self.step = Step::StartTagQuotedAttributeValue;
 502 |                                 },
 503 |                                 _ => {
 504 |                                     if is_whitespace(e) {
 505 |                                         start = p + 1;
 506 |                                     } else {
 507 |                                         if self.in_attribute_type {
 508 |                                             self.attribute_type.push(e);
 509 |                                         }
 510 | 
 511 |                                         out.push(b'=')?;
 512 | 
 513 |                                         self.step = Step::StartTagUnquotedAttributeValue;
 514 |                                     }
 515 |                                 },
 516 |                             }
 517 |                         },
 518 |                         Step::StartTagQuotedAttributeValue => {
 519 |                             // <a a="?
 520 |                             // <a a='?
 521 |                             // NOTE: Backslashes cannot be used for escaping.
 522 |                             if e == self.quote {
 523 |                                 if self.quoted_value_empty {
 524 |                                     start = p + 1;
 525 |                                 }
 526 | 
 527 |                                 self.finish_buffer();
 528 | 
 529 |                                 out.push_bytes(&text_bytes[start..=p])?;
 530 |                                 start = p + 1;
 531 | 
 532 |                                 self.last_space = 0;
 533 |                                 self.step = Step::StartTagIn;
 534 |                             } else if self.in_handled_attribute && is_whitespace(e) {
 535 |                                 if self.quoted_value_empty {
 536 |                                     start = p + 1;
 537 |                                 } else if self.quoted_value_spacing {
 538 |                                     debug_assert_eq!(start, p);
 539 |                                     start = p + 1;
 540 |                                 } else {
 541 |                                     out.push_bytes(&text_bytes[start..p])?;
 542 |                                     start = p + 1;
 543 | 
 544 |                                     self.quoted_value_spacing = true;
 545 |                                     self.quoted_value_empty = false;
 546 |                                 }
 547 |                             } else {
 548 |                                 if self.quoted_value_empty {
 549 |                                     self.quoted_value_empty = false;
 550 | 
 551 |                                     out.push_bytes(&[b'=', self.quote])?;
 552 |                                 } else if self.quoted_value_spacing {
 553 |                                     out.push_bytes(&text_bytes[start..p])?;
 554 |                                     start = p;
 555 | 
 556 |                                     out.push(b' ')?;
 557 |                                 }
 558 | 
 559 |                                 if self.in_attribute_type {
 560 |                                     if self.quoted_value_spacing {
 561 |                                         self.attribute_type.push(b' ');
 562 |                                     }
 563 | 
 564 |                                     self.attribute_type.push(e);
 565 |                                 }
 566 | 
 567 |                                 self.quoted_value_spacing = false;
 568 |                             }
 569 |                         },
 570 |                         Step::StartTagUnquotedAttributeValue => {
 571 |                             // <a a=v?
 572 |                             // <a a=v?
 573 |                             match e {
 574 |                                 b'>' => {
 575 |                                     self.finish_buffer();
 576 | 
 577 |                                     self.last_space = 0;
 578 |                                     self.step = Step::InitialRemainOneWhitespace;
 579 |                                 },
 580 |                                 _ => {
 581 |                                     if is_whitespace(e) {
 582 |                                         self.finish_buffer();
 583 | 
 584 |                                         out.push_bytes(&text_bytes[start..p])?;
 585 |                                         start = p + 1;
 586 | 
 587 |                                         self.last_space = e;
 588 |                                         self.step = Step::StartTagIn;
 589 |                                     } else if self.in_attribute_type {
 590 |                                         self.attribute_type.push(e);
 591 |                                     }
 592 |                                 },
 593 |                             }
 594 |                         },
 595 |                         Step::EndTag => {
 596 |                             // </a?
 597 |                             if is_whitespace(e) {
 598 |                                 out.push_bytes(&text_bytes[start..p])?;
 599 |                                 start = p + 1;
 600 | 
 601 |                                 self.step = Step::TagEnd;
 602 |                             } else if e == b'>' {
 603 |                                 self.last_space = 0;
 604 |                                 self.step = Step::InitialRemainOneWhitespace;
 605 |                             }
 606 |                         },
 607 |                         Step::TagEnd => {
 608 |                             // <a/?
 609 |                             // </a ?
 610 |                             match e {
 611 |                                 b'>' => {
 612 |                                     self.last_space = 0;
 613 |                                     self.step = Step::InitialRemainOneWhitespace;
 614 |                                 },
 615 |                                 _ => {
 616 |                                     out.push_bytes(&text_bytes[start..p])?;
 617 |                                     start = p + 1;
 618 |                                 },
 619 |                             }
 620 |                         },
 621 |                         Step::Doctype => {
 622 |                             // <!?
 623 |                             if e == b'>' {
 624 |                                 if self.step_counter == 0 {
 625 |                                     out.push_bytes(b"<!")?;
 626 |                                 }
 627 | 
 628 |                                 self.last_space = 0;
 629 |                                 self.step = Step::InitialRemainOneWhitespace;
 630 |                             } else {
 631 |                                 match self.step_counter {
 632 |                                     0 => match e {
 633 |                                         b'-' => {
 634 |                                             start = p + 1;
 635 | 
 636 |                                             self.step_counter = 1;
 637 |                                         },
 638 |                                         _ => {
 639 |                                             out.push_bytes(b"<!")?;
 640 | 
 641 |                                             self.step_counter = 255;
 642 |                                         },
 643 |                                     },
 644 |                                     1 => match e {
 645 |                                         b'-' => {
 646 |                                             if !self.remove_comments {
 647 |                                                 out.push_bytes(b"<!--")?;
 648 |                                             }
 649 | 
 650 |                                             start = p + 1;
 651 | 
 652 |                                             self.step_counter = 0;
 653 |                                             self.step = Step::Comment;
 654 |                                         },
 655 |                                         _ => {
 656 |                                             out.push_bytes(b"<!-")?;
 657 | 
 658 |                                             self.step_counter = 255;
 659 |                                         },
 660 |                                     },
 661 |                                     255 => (),
 662 |                                     _ => unreachable!(),
 663 |                                 }
 664 |                             }
 665 |                         },
 666 |                         Step::Comment => {
 667 |                             // <!--?
 668 |                             if self.remove_comments {
 669 |                                 debug_assert_eq!(start, p);
 670 |                                 start = p + 1;
 671 |                             }
 672 | 
 673 |                             match self.step_counter {
 674 |                                 0 => {
 675 |                                     if e == b'-' {
 676 |                                         self.step_counter = 1;
 677 |                                     }
 678 |                                 },
 679 |                                 1 => match e {
 680 |                                     b'-' => self.step_counter = 2,
 681 |                                     _ => self.step_counter = 0,
 682 |                                 },
 683 |                                 2 => {
 684 |                                     match e {
 685 |                                         b'>' => {
 686 |                                             if self.last_space > 0 {
 687 |                                                 self.last_space = 0;
 688 | 
 689 |                                                 self.step = Step::InitialIgnoreWhitespace;
 690 |                                             } else {
 691 |                                                 // No need to set `last_space`.
 692 |                                                 self.step = Step::InitialRemainOneWhitespace;
 693 |                                             }
 694 |                                         },
 695 |                                         _ => self.step_counter = 0,
 696 |                                     }
 697 |                                 },
 698 |                                 _ => unreachable!(),
 699 |                             }
 700 |                         },
 701 |                         Step::ScriptDefault => match self.step_counter {
 702 |                             0 => {
 703 |                                 if e == b'<' {
 704 |                                     self.step_counter = 1;
 705 |                                 }
 706 |                             },
 707 |                             1 => match e {
 708 |                                 b'/' => self.step_counter = 2,
 709 |                                 _ => self.step_counter = 0,
 710 |                             },
 711 |                             2 => match e {
 712 |                                 b's' | b'S' => self.step_counter = 3,
 713 |                                 _ => self.step_counter = 0,
 714 |                             },
 715 |                             3 => match e {
 716 |                                 b'c' | b'C' => self.step_counter = 4,
 717 |                                 _ => self.step_counter = 0,
 718 |                             },
 719 |                             4 => match e {
 720 |                                 b'r' | b'R' => self.step_counter = 5,
 721 |                                 _ => self.step_counter = 0,
 722 |                             },
 723 |                             5 => match e {
 724 |                                 b'i' | b'I' => self.step_counter = 6,
 725 |                                 _ => self.step_counter = 0,
 726 |                             },
 727 |                             6 => match e {
 728 |                                 b'p' | b'P' => self.step_counter = 7,
 729 |                                 _ => self.step_counter = 0,
 730 |                             },
 731 |                             7 => match e {
 732 |                                 b't' | b'T' => self.step_counter = 8,
 733 |                                 _ => self.step_counter = 0,
 734 |                             },
 735 |                             8 => match e {
 736 |                                 b'>' => {
 737 |                                     self.last_space = 0;
 738 |                                     self.step = Step::InitialRemainOneWhitespace;
 739 |                                 },
 740 |                                 _ => {
 741 |                                     if is_whitespace(e) {
 742 |                                         out.push_bytes(&text_bytes[start..p])?;
 743 |                                         start = p + 1;
 744 | 
 745 |                                         self.step = Step::TagEnd;
 746 |                                     } else {
 747 |                                         self.step_counter = 0;
 748 |                                     }
 749 |                                 },
 750 |                             },
 751 |                             _ => unreachable!(),
 752 |                         },
 753 |                         Step::ScriptJavaScript => match self.step_counter {
 754 |                             0 => {
 755 |                                 if e == b'<' {
 756 |                                     self.step_counter = 1;
 757 |                                 }
 758 |                             },
 759 |                             1 => match e {
 760 |                                 b'/' => self.step_counter = 2,
 761 |                                 _ => self.step_counter = 0,
 762 |                             },
 763 |                             2 => match e {
 764 |                                 b's' | b'S' => self.step_counter = 3,
 765 |                                 _ => self.step_counter = 0,
 766 |                             },
 767 |                             3 => match e {
 768 |                                 b'c' | b'C' => self.step_counter = 4,
 769 |                                 _ => self.step_counter = 0,
 770 |                             },
 771 |                             4 => match e {
 772 |                                 b'r' | b'R' => self.step_counter = 5,
 773 |                                 _ => self.step_counter = 0,
 774 |                             },
 775 |                             5 => match e {
 776 |                                 b'i' | b'I' => self.step_counter = 6,
 777 |                                 _ => self.step_counter = 0,
 778 |                             },
 779 |                             6 => match e {
 780 |                                 b'p' | b'P' => self.step_counter = 7,
 781 |                                 _ => self.step_counter = 0,
 782 |                             },
 783 |                             7 => match e {
 784 |                                 b't' | b'T' => self.step_counter = 8,
 785 |                                 _ => self.step_counter = 0,
 786 |                             },
 787 |                             8 => match e {
 788 |                                 b'>' => {
 789 |                                     self.buffer.extend_from_slice(&text_bytes[start..=p]);
 790 |                                     start = p + 1;
 791 | 
 792 |                                     let script_length = self.buffer.len() - 9;
 793 | 
 794 |                                     let minified_js = js::minify(unsafe {
 795 |                                         from_utf8_unchecked(&self.buffer[..script_length])
 796 |                                     });
 797 |                                     out.push_bytes(minified_js.to_string().as_bytes())?;
 798 |                                     out.push_bytes(&self.buffer[script_length..])?;
 799 | 
 800 |                                     self.last_space = 0;
 801 |                                     self.step = Step::InitialRemainOneWhitespace;
 802 |                                 },
 803 |                                 _ => {
 804 |                                     if is_whitespace(e) {
 805 |                                         self.buffer.extend_from_slice(&text_bytes[start..p]);
 806 |                                         start = p + 1;
 807 | 
 808 |                                         let buffer_length = self.buffer.len();
 809 |                                         let script_length = buffer_length - 8;
 810 | 
 811 |                                         let minified_js = js::minify(unsafe {
 812 |                                             from_utf8_unchecked(&self.buffer[..script_length])
 813 |                                         });
 814 |                                         out.push_bytes(minified_js.to_string().as_bytes())?;
 815 |                                         out.push_bytes(&self.buffer[script_length..])?;
 816 | 
 817 |                                         self.step = Step::TagEnd;
 818 |                                     } else {
 819 |                                         self.step_counter = 0;
 820 |                                     }
 821 |                                 },
 822 |                             },
 823 |                             _ => unreachable!(),
 824 |                         },
 825 |                         Step::StyleDefault => match self.step_counter {
 826 |                             0 => {
 827 |                                 if e == b'<' {
 828 |                                     self.step_counter = 1;
 829 |                                 }
 830 |                             },
 831 |                             1 => match e {
 832 |                                 b'/' => self.step_counter = 2,
 833 |                                 _ => self.step_counter = 0,
 834 |                             },
 835 |                             2 => match e {
 836 |                                 b's' | b'S' => self.step_counter = 3,
 837 |                                 _ => self.step_counter = 0,
 838 |                             },
 839 |                             3 => match e {
 840 |                                 b't' | b'T' => self.step_counter = 4,
 841 |                                 _ => self.step_counter = 0,
 842 |                             },
 843 |                             4 => match e {
 844 |                                 b'y' | b'Y' => self.step_counter = 5,
 845 |                                 _ => self.step_counter = 0,
 846 |                             },
 847 |                             5 => match e {
 848 |                                 b'l' | b'L' => self.step_counter = 6,
 849 |                                 _ => self.step_counter = 0,
 850 |                             },
 851 |                             6 => match e {
 852 |                                 b'e' | b'E' => self.step_counter = 7,
 853 |                                 _ => self.step_counter = 0,
 854 |                             },
 855 |                             7 => match e {
 856 |                                 b'>' => {
 857 |                                     self.last_space = 0;
 858 |                                     self.step = Step::InitialRemainOneWhitespace;
 859 |                                 },
 860 |                                 _ => {
 861 |                                     if is_whitespace(e) {
 862 |                                         out.push_bytes(&text_bytes[start..p])?;
 863 |                                         start = p + 1;
 864 | 
 865 |                                         self.step = Step::TagEnd;
 866 |                                     } else {
 867 |                                         self.step_counter = 0;
 868 |                                     }
 869 |                                 },
 870 |                             },
 871 |                             _ => unreachable!(),
 872 |                         },
 873 |                         Step::StyleCSS => match self.step_counter {
 874 |                             0 => {
 875 |                                 if e == b'<' {
 876 |                                     self.step_counter = 1;
 877 |                                 }
 878 |                             },
 879 |                             1 => match e {
 880 |                                 b'/' => self.step_counter = 2,
 881 |                                 _ => self.step_counter = 0,
 882 |                             },
 883 |                             2 => match e {
 884 |                                 b's' | b'S' => self.step_counter = 3,
 885 |                                 _ => self.step_counter = 0,
 886 |                             },
 887 |                             3 => match e {
 888 |                                 b't' | b'T' => self.step_counter = 4,
 889 |                                 _ => self.step_counter = 0,
 890 |                             },
 891 |                             4 => match e {
 892 |                                 b'y' | b'Y' => self.step_counter = 5,
 893 |                                 _ => self.step_counter = 0,
 894 |                             },
 895 |                             5 => match e {
 896 |                                 b'l' | b'L' => self.step_counter = 6,
 897 |                                 _ => self.step_counter = 0,
 898 |                             },
 899 |                             6 => match e {
 900 |                                 b'e' | b'E' => self.step_counter = 7,
 901 |                                 _ => self.step_counter = 0,
 902 |                             },
 903 |                             7 => match e {
 904 |                                 b'>' => {
 905 |                                     self.buffer.extend_from_slice(&text_bytes[start..=p]);
 906 |                                     start = p + 1;
 907 | 
 908 |                                     let script_length = self.buffer.len() - 8;
 909 | 
 910 |                                     let minified_css = css::minify(unsafe {
 911 |                                         from_utf8_unchecked(&self.buffer[..script_length])
 912 |                                     })
 913 |                                     .map_err(HTMLMinifierError::CSSError)?;
 914 |                                     out.push_bytes(minified_css.to_string().as_bytes())?;
 915 |                                     out.push_bytes(&self.buffer[script_length..])?;
 916 | 
 917 |                                     self.last_space = 0;
 918 |                                     self.step = Step::InitialRemainOneWhitespace;
 919 |                                 },
 920 |                                 _ => {
 921 |                                     if is_whitespace(e) {
 922 |                                         self.buffer.extend_from_slice(&text_bytes[start..p]);
 923 |                                         start = p + 1;
 924 | 
 925 |                                         let buffer_length = self.buffer.len();
 926 |                                         let script_length = buffer_length - 7;
 927 | 
 928 |                                         let minified_css = css::minify(unsafe {
 929 |                                             from_utf8_unchecked(&self.buffer[..script_length])
 930 |                                         })
 931 |                                         .map_err(HTMLMinifierError::CSSError)?;
 932 |                                         out.push_bytes(minified_css.to_string().as_bytes())?;
 933 |                                         out.push_bytes(&self.buffer[script_length..])?;
 934 | 
 935 |                                         self.step = Step::TagEnd;
 936 |                                     } else {
 937 |                                         self.step_counter = 0;
 938 |                                     }
 939 |                                 },
 940 |                             },
 941 |                             _ => unreachable!(),
 942 |                         },
 943 |                         Step::Pre => match self.step_counter {
 944 |                             0 => {
 945 |                                 if e == b'<' {
 946 |                                     self.step_counter = 1;
 947 |                                 }
 948 |                             },
 949 |                             1 => match e {
 950 |                                 b'/' => self.step_counter = 2,
 951 |                                 _ => self.step_counter = 0,
 952 |                             },
 953 |                             2 => match e {
 954 |                                 b'p' | b'P' => self.step_counter = 3,
 955 |                                 _ => self.step_counter = 0,
 956 |                             },
 957 |                             3 => match e {
 958 |                                 b'r' | b'R' => self.step_counter = 4,
 959 |                                 _ => self.step_counter = 0,
 960 |                             },
 961 |                             4 => match e {
 962 |                                 b'e' | b'E' => self.step_counter = 5,
 963 |                                 _ => self.step_counter = 0,
 964 |                             },
 965 |                             5 => match e {
 966 |                                 b'>' => {
 967 |                                     self.last_space = 0;
 968 |                                     self.step = Step::InitialRemainOneWhitespace;
 969 |                                 },
 970 |                                 _ => {
 971 |                                     if is_whitespace(e) {
 972 |                                         out.push_bytes(&text_bytes[start..p])?;
 973 |                                         start = p + 1;
 974 | 
 975 |                                         self.step = Step::TagEnd;
 976 |                                     } else {
 977 |                                         self.step_counter = 0;
 978 |                                     }
 979 |                                 },
 980 |                             },
 981 |                             _ => unreachable!(),
 982 |                         },
 983 |                         Step::Code => match self.step_counter {
 984 |                             0 => {
 985 |                                 if e == b'<' {
 986 |                                     self.step_counter = 1;
 987 |                                 }
 988 |                             },
 989 |                             1 => match e {
 990 |                                 b'/' => self.step_counter = 2,
 991 |                                 _ => self.step_counter = 0,
 992 |                             },
 993 |                             2 => match e {
 994 |                                 b'c' | b'C' => self.step_counter = 3,
 995 |                                 _ => self.step_counter = 0,
 996 |                             },
 997 |                             3 => match e {
 998 |                                 b'o' | b'O' => self.step_counter = 4,
 999 |                                 _ => self.step_counter = 0,
1000 |                             },
1001 |                             4 => match e {
1002 |                                 b'd' | b'D' => self.step_counter = 5,
1003 |                                 _ => self.step_counter = 0,
1004 |                             },
1005 |                             5 => match e {
1006 |                                 b'e' | b'E' => self.step_counter = 6,
1007 |                                 _ => self.step_counter = 0,
1008 |                             },
1009 |                             6 => match e {
1010 |                                 b'>' => {
1011 |                                     self.last_space = 0;
1012 |                                     self.step = Step::InitialRemainOneWhitespace;
1013 |                                 },
1014 |                                 _ => {
1015 |                                     if is_whitespace(e) {
1016 |                                         out.push_bytes(&text_bytes[start..p])?;
1017 |                                         start = p + 1;
1018 | 
1019 |                                         self.step = Step::TagEnd;
1020 |                                     } else {
1021 |                                         self.step_counter = 0;
1022 |                                     }
1023 |                                 },
1024 |                             },
1025 |                             _ => unreachable!(),
1026 |                         },
1027 |                         Step::Textarea => match self.step_counter {
1028 |                             0 => {
1029 |                                 if e == b'<' {
1030 |                                     self.step_counter = 1;
1031 |                                 }
1032 |                             },
1033 |                             1 => match e {
1034 |                                 b'/' => self.step_counter = 2,
1035 |                                 _ => self.step_counter = 0,
1036 |                             },
1037 |                             2 => match e {
1038 |                                 b't' | b'T' => self.step_counter = 3,
1039 |                                 _ => self.step_counter = 0,
1040 |                             },
1041 |                             3 => match e {
1042 |                                 b'e' | b'E' => self.step_counter = 4,
1043 |                                 _ => self.step_counter = 0,
1044 |                             },
1045 |                             4 => match e {
1046 |                                 b'x' | b'X' => self.step_counter = 5,
1047 |                                 _ => self.step_counter = 0,
1048 |                             },
1049 |                             5 => match e {
1050 |                                 b't' | b'T' => self.step_counter = 6,
1051 |                                 _ => self.step_counter = 0,
1052 |                             },
1053 |                             6 => match e {
1054 |                                 b'a' | b'A' => self.step_counter = 7,
1055 |                                 _ => self.step_counter = 0,
1056 |                             },
1057 |                             7 => match e {
1058 |                                 b'r' | b'R' => self.step_counter = 8,
1059 |                                 _ => self.step_counter = 0,
1060 |                             },
1061 |                             8 => match e {
1062 |                                 b'e' | b'E' => self.step_counter = 9,
1063 |                                 _ => self.step_counter = 0,
1064 |                             },
1065 |                             9 => match e {
1066 |                                 b'a' | b'A' => self.step_counter = 10,
1067 |                                 _ => self.step_counter = 0,
1068 |                             },
1069 |                             10 => match e {
1070 |                                 b'>' => {
1071 |                                     self.last_space = 0;
1072 |                                     self.step = Step::InitialRemainOneWhitespace;
1073 |                                 },
1074 |                                 _ => {
1075 |                                     if is_whitespace(e) {
1076 |                                         out.push_bytes(&text_bytes[start..p])?;
1077 |                                         start = p + 1;
1078 | 
1079 |                                         self.step = Step::TagEnd;
1080 |                                     } else {
1081 |                                         self.step_counter = 0;
1082 |                                     }
1083 |                                 },
1084 |                             },
1085 |                             _ => unreachable!(),
1086 |                         },
1087 |                     }
1088 |                 }
1089 |             } else {
1090 |                 // non-ASCII
1091 |                 match self.step {
1092 |                     Step::Initial => {
1093 |                         // ?
1094 |                         self.last_space = 0;
1095 |                         self.step = Step::InitialRemainOneWhitespace;
1096 |                     },
1097 |                     Step::InitialRemainOneWhitespace => {
1098 |                         // a?
1099 |                         self.last_space = 0;
1100 |                     },
1101 |                     Step::InitialIgnoreWhitespace => {
1102 |                         // a ?
1103 |                         if self.last_space == b'\n' {
1104 |                             out.push(b'\n')?;
1105 |                         } else if self.last_space > 0 {
1106 |                             out.push(b' ')?;
1107 |                         }
1108 | 
1109 |                         self.last_space = 0;
1110 |                         self.step = Step::InitialRemainOneWhitespace;
1111 |                     },
1112 |                     Step::StartTagInitial => {
1113 |                         // <?
1114 |                         // To `InitialRemainOneWhitespace`.
1115 |                         debug_assert_eq!(start, p);
1116 | 
1117 |                         out.push(b'<')?;
1118 | 
1119 |                         self.last_space = 0;
1120 |                         self.step = Step::InitialRemainOneWhitespace;
1121 |                     },
1122 |                     Step::EndTagInitial => {
1123 |                         // </?
1124 |                         // To `InitialRemainOneWhitespace`.
1125 |                         out.push_bytes(b"</")?;
1126 | 
1127 |                         self.last_space = 0;
1128 |                         self.step = Step::InitialRemainOneWhitespace;
1129 |                     },
1130 |                     Step::StartTag | Step::EndTag => {
1131 |                         // <a?
1132 |                         // </a?
1133 |                         // To `InitialRemainOneWhitespace`.
1134 |                         self.last_space = 0;
1135 |                         self.step = Step::InitialRemainOneWhitespace;
1136 |                     },
1137 |                     Step::StartTagIn => {
1138 |                         // <a ?
1139 |                         out.push(b' ')?;
1140 | 
1141 |                         self.buffer.clear();
1142 |                         self.buffer.push(e);
1143 | 
1144 |                         self.step = Step::StartTagAttributeName;
1145 |                     },
1146 |                     Step::StartTagAttributeName => {
1147 |                         // <a a?
1148 |                         self.buffer.push(e);
1149 |                     },
1150 |                     Step::StartTagAttributeNameWaitingValue => {
1151 |                         // <a a ?
1152 |                         out.push(b' ')?;
1153 | 
1154 |                         self.buffer.clear();
1155 |                         self.buffer.push(e);
1156 | 
1157 |                         self.step = Step::StartTagAttributeName;
1158 |                     },
1159 |                     Step::StartTagAttributeValueInitial => {
1160 |                         // <a a=?
1161 |                         debug_assert_eq!(start, p);
1162 | 
1163 |                         if self.in_attribute_type {
1164 |                             self.attribute_type.push(e);
1165 |                         }
1166 | 
1167 |                         out.push(b'=')?;
1168 | 
1169 |                         self.step = Step::StartTagUnquotedAttributeValue;
1170 |                     },
1171 |                     Step::StartTagQuotedAttributeValue => {
1172 |                         // <a a="?
1173 |                         // <a a='?
1174 |                         if self.quoted_value_empty {
1175 |                             self.quoted_value_empty = false;
1176 | 
1177 |                             out.push_bytes(&[b'=', self.quote])?;
1178 |                         }
1179 | 
1180 |                         self.quoted_value_spacing = false;
1181 | 
1182 |                         if self.in_attribute_type {
1183 |                             self.attribute_type.push(e);
1184 |                         }
1185 |                     },
1186 |                     Step::StartTagUnquotedAttributeValue => {
1187 |                         // <a a=v?
1188 |                         // <a a=v?
1189 |                         if self.in_attribute_type {
1190 |                             self.attribute_type.push(e);
1191 |                         }
1192 |                     },
1193 |                     Step::TagEnd => {
1194 |                         // <a/?
1195 |                         // </a ?
1196 |                         out.push_bytes(&text_bytes[start..p])?;
1197 |                         start = p + 1;
1198 |                     },
1199 |                     Step::Doctype => {
1200 |                         // <!?
1201 |                         if self.step_counter == 0 {
1202 |                             out.push_bytes(b"<!")?;
1203 |                         }
1204 | 
1205 |                         self.step_counter = 255;
1206 |                     },
1207 |                     Step::Comment => {
1208 |                         // <!--?
1209 |                         if self.remove_comments {
1210 |                             debug_assert_eq!(start, p);
1211 |                             start = p + 1;
1212 |                         }
1213 | 
1214 |                         self.step_counter = 0;
1215 |                     },
1216 |                     Step::ScriptDefault
1217 |                     | Step::StyleDefault
1218 |                     | Step::Pre
1219 |                     | Step::Code
1220 |                     | Step::Textarea
1221 |                     | Step::ScriptJavaScript
1222 |                     | Step::StyleCSS => {
1223 |                         self.step_counter = 0;
1224 |                     },
1225 |                 }
1226 |             }
1227 | 
1228 |             p += 1;
1229 |         }
1230 | 
1231 |         match self.step {
1232 |             Step::ScriptJavaScript | Step::StyleCSS => {
1233 |                 self.buffer.extend_from_slice(&text_bytes[start..p]);
1234 |             },
1235 |             _ => out.push_bytes(&text_bytes[start..p])?,
1236 |         }
1237 | 
1238 |         Ok(())
1239 |     }
1240 | }
1241 | 


--------------------------------------------------------------------------------