├── .github
    ├── dependabot.yml
    └── workflows
    │   ├── ci-version.yml
    │   └── ci.yml
├── .gitignore
├── Cargo.toml
├── LICENSE
├── README.md
├── benches
    ├── data
    │   └── vgilante.txt
    └── encode.rs
├── rustfmt.toml
├── src
    ├── decode
    │   ├── element
    │   │   ├── decode_impl.rs
    │   │   ├── mod.rs
    │   │   ├── script.rs
    │   │   └── style.rs
    │   ├── html_entity
    │   │   ├── mod.rs
    │   │   └── tables.rs
    │   └── mod.rs
    ├── encode
    │   ├── element
    │   │   ├── encode_impl.rs
    │   │   ├── mod.rs
    │   │   ├── script.rs
    │   │   └── style.rs
    │   ├── html_entity
    │   │   ├── mod.rs
    │   │   └── unquoted_attribute.rs
    │   └── mod.rs
    ├── functions.rs
    └── lib.rs
└── tests
    ├── element.rs
    └── html_entity.rs


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


--------------------------------------------------------------------------------
/.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.58
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 }}


--------------------------------------------------------------------------------
/.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.58
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 }}


--------------------------------------------------------------------------------
/.gitignore:
--------------------------------------------------------------------------------
 1 | # Created by https://www.gitignore.io/api/intellij+all
 2 | 
 3 | ### Intellij+all ###
 4 | # Covers JetBrains IDEs: IntelliJ, RubyMine, PhpStorm, AppCode, PyCharm, CLion, Android Studio and WebStorm
 5 | # Reference: https://intellij-support.jetbrains.com/hc/en-us/articles/206544839
 6 | 
 7 | # User-specific stuff
 8 | .idea/**/workspace.xml
 9 | .idea/**/tasks.xml
10 | .idea/**/usage.statistics.xml
11 | .idea/**/dictionaries
12 | .idea/**/shelf
13 | 
14 | # Sensitive or high-churn files
15 | .idea/**/dataSources/
16 | .idea/**/dataSources.ids
17 | .idea/**/dataSources.local.xml
18 | .idea/**/sqlDataSources.xml
19 | .idea/**/dynamic.xml
20 | .idea/**/uiDesigner.xml
21 | .idea/**/dbnavigator.xml
22 | 
23 | # Gradle
24 | .idea/**/gradle.xml
25 | .idea/**/libraries
26 | 
27 | # Gradle and Maven with auto-import
28 | # When using Gradle or Maven with auto-import, you should exclude module files,
29 | # since they will be recreated, and may cause churn.  Uncomment if using
30 | # auto-import.
31 | # .idea/modules.xml
32 | # .idea/*.iml
33 | # .idea/modules
34 | 
35 | # CMake
36 | cmake-build-*/
37 | 
38 | # Mongo Explorer plugin
39 | .idea/**/mongoSettings.xml
40 | 
41 | # File-based project format
42 | *.iws
43 | 
44 | # IntelliJ
45 | out/
46 | 
47 | # mpeltonen/sbt-idea plugin
48 | .idea_modules/
49 | 
50 | # JIRA plugin
51 | atlassian-ide-plugin.xml
52 | 
53 | # Cursive Clojure plugin
54 | .idea/replstate.xml
55 | 
56 | # Crashlytics plugin (for Android Studio and IntelliJ)
57 | com_crashlytics_export_strings.xml
58 | crashlytics.properties
59 | crashlytics-build.properties
60 | fabric.properties
61 | 
62 | # Editor-based Rest Client
63 | .idea/httpRequests
64 | 
65 | ### Intellij+all Patch ###
66 | # Ignores the whole .idea folder and all .iml files
67 | # See https://github.com/joeblau/gitignore.io/issues/186 and https://github.com/joeblau/gitignore.io/issues/360
68 | 
69 | .idea/
70 | 
71 | # Reason: https://github.com/joeblau/gitignore.io/issues/186#issuecomment-249601023
72 | 
73 | *.iml
74 | modules.xml
75 | .idea/misc.xml
76 | *.ipr
77 | 
78 | 
79 | # End of https://www.gitignore.io/api/intellij+all
80 | 
81 | 
82 | ### Rust ###
83 | # Generated by Cargo
84 | # will have compiled files and executables
85 | /target/
86 | 
87 | # Remove Cargo.lock from gitignore if creating an executable, leave it for libraries
88 | # More information here https://doc.rust-lang.org/cargo/guide/cargo-toml-vs-cargo-lock.html
89 | Cargo.lock
90 | 
91 | # These are backup files generated by rustfmt
92 | **/*.rs.bk
93 | 
94 | 
95 | # End of https://www.gitignore.io/api/rust
96 | 


--------------------------------------------------------------------------------
/Cargo.toml:
--------------------------------------------------------------------------------
 1 | [package]
 2 | name = "html-escape"
 3 | version = "0.2.13"
 4 | authors = ["Magic Len <len@magiclen.org>"]
 5 | edition = "2021"
 6 | rust-version = "1.58"
 7 | repository = "https://github.com/magiclen/html-escape"
 8 | homepage = "https://magiclen.org/html-escape"
 9 | keywords = ["html", "escape", "unescape", "encode", "decode"]
10 | categories = ["no-std", "encoding"]
11 | description = "This library is for encoding/escaping special characters in HTML and decoding/unescaping HTML entities as well."
12 | license = "MIT"
13 | include = ["src/**/*", "Cargo.toml", "README.md", "LICENSE", "benches/encode.rs"]
14 | 
15 | [dependencies]
16 | utf8-width = "0.1"
17 | 
18 | [dev-dependencies]
19 | bencher = "0.1.5"
20 | 
21 | [features]
22 | default = ["std"]
23 | std = []
24 | 
25 | [[bench]]
26 | name = "encode"
27 | required-features = ["std"]
28 | harness = false
29 | 


--------------------------------------------------------------------------------
/LICENSE:
--------------------------------------------------------------------------------
 1 | MIT License
 2 | 
 3 | Copyright (c) 2020 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 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
 1 | HTML Escape
 2 | ====================
 3 | 
 4 | [![CI](https://github.com/magiclen/html-escape/actions/workflows/ci.yml/badge.svg)](https://github.com/magiclen/html-escape/actions/workflows/ci.yml)
 5 | 
 6 | This library is for encoding/escaping special characters in HTML and decoding/unescaping HTML entities as well.
 7 | 
 8 | ## Usage
 9 | 
10 | ### Encoding
11 | 
12 | This crate provides some `encode_*` functions to encode HTML text in different situations.
13 | 
14 | For example, to put a text between a start tag `<foo>` and an end tag `</foo>`, use the `encode_text` function to escape every `&`, `<`, and `>` in the text.
15 | 
16 | ```rust
17 | assert_eq!("a &gt; b &amp;&amp; a &lt; c", html_escape::encode_text("a > b && a < c"));
18 | ```
19 | 
20 | The functions suffixed with `_to_writer`, `_to_vec` or `_to_string` are useful to generate HTML.
21 | 
22 | ```rust
23 | let mut html = String::from("<input value=");
24 | assert_eq!("Hello&#x20;world&#x21;", html_escape::encode_unquoted_attribute_to_string("Hello world!", &mut html));
25 | html.push_str(" placeholder=\"");
26 | assert_eq!("The default value is &quot;Hello world!&quot;.", html_escape::encode_double_quoted_attribute_to_string("The default value is \"Hello world!\".", &mut html));
27 | html.push_str("\"/><script>alert('");
28 | assert_eq!(r"<script>\'s end tag is <\/script>", html_escape::encode_script_single_quoted_text_to_string("<script>'s end tag is </script>", &mut html));
29 | html.push_str("');</script>");
30 | 
31 | assert_eq!("<input value=Hello&#x20;world&#x21; placeholder=\"The default value is &quot;Hello world!&quot;.\"/><script>alert(\'<script>\\\'s end tag is <\\/script>\');</script>", html);
32 | ```
33 | 
34 | ### Decoding
35 | 
36 | ```rust
37 | assert_eq!("Hello world!", html_escape::decode_html_entities("Hello&#x20;world&#x21;"));
38 | ```
39 | 
40 | ```rust
41 | assert_eq!("alert('<script></script>);'", html_escape::decode_script(r"alert('<script><\/script>);'"));
42 | ```
43 | 
44 | ## No Std
45 | 
46 | Disable the default features to compile this crate without std.
47 | 
48 | ```toml
49 | [dependencies.html-escape]
50 | version = "*"
51 | default-features = false
52 | ```
53 | 
54 | ## Benchmark
55 | 
56 | ```bash
57 | cargo bench
58 | ```
59 | 
60 | ## Crates.io
61 | 
62 | https://crates.io/crates/html-escape
63 | 
64 | ## Documentation
65 | 
66 | https://docs.rs/html-escape
67 | 
68 | ## License
69 | 
70 | [MIT](LICENSE)


--------------------------------------------------------------------------------
/benches/encode.rs:
--------------------------------------------------------------------------------
  1 | use std::fs;
  2 | 
  3 | use bencher::{benchmark_group, benchmark_main, Bencher};
  4 | 
  5 | #[cfg(unix)]
  6 | const TEXT_PATH: &str = "benches/data/vgilante.txt";
  7 | 
  8 | #[cfg(windows)]
  9 | const TEXT_PATH: &str = r"benches\data\vgilante.txt";
 10 | 
 11 | macro_rules! benchmark_impl {
 12 |     ($g:ident, $f:ident, $f_to_string:ident, $f_to_writer:ident) => {
 13 |         fn $f(bencher: &mut Bencher) {
 14 |             let text = fs::read_to_string(TEXT_PATH).unwrap();
 15 |             let length = text.len();
 16 | 
 17 |             bencher.iter(|| html_escape::$f(text.as_str()));
 18 |             bencher.bytes = length as u64;
 19 |         }
 20 | 
 21 |         fn $f_to_string(bencher: &mut Bencher) {
 22 |             let text = fs::read_to_string(TEXT_PATH).unwrap();
 23 |             let length = text.len();
 24 | 
 25 |             bencher.iter(|| {
 26 |                 let mut s = String::new();
 27 | 
 28 |                 html_escape::$f_to_string(text.as_str(), &mut s);
 29 | 
 30 |                 s
 31 |             });
 32 |             bencher.bytes = length as u64;
 33 |         }
 34 | 
 35 |         fn $f_to_writer(bencher: &mut Bencher) {
 36 |             let text = fs::read_to_string(TEXT_PATH).unwrap();
 37 |             let length = text.len();
 38 | 
 39 |             bencher.iter(|| {
 40 |                 let mut v = Vec::new();
 41 | 
 42 |                 html_escape::$f_to_writer(text.as_str(), &mut v).unwrap();
 43 | 
 44 |                 v
 45 |             });
 46 |             bencher.bytes = length as u64;
 47 |         }
 48 | 
 49 |         benchmark_group!($g, $f, $f_to_string, $f_to_writer);
 50 |     };
 51 | }
 52 | 
 53 | benchmark_impl!(
 54 |     text_minimal,
 55 |     encode_text_minimal,
 56 |     encode_text_minimal_to_string,
 57 |     encode_text_minimal_to_writer
 58 | );
 59 | 
 60 | benchmark_impl!(text, encode_text, encode_text_to_string, encode_text_to_writer);
 61 | 
 62 | benchmark_impl!(
 63 |     double_quoted_attribute,
 64 |     encode_double_quoted_attribute,
 65 |     encode_double_quoted_attribute_to_string,
 66 |     encode_double_quoted_attribute_to_writer
 67 | );
 68 | 
 69 | benchmark_impl!(
 70 |     single_quoted_attribute,
 71 |     encode_single_quoted_attribute,
 72 |     encode_single_quoted_attribute_to_string,
 73 |     encode_single_quoted_attribute_to_writer
 74 | );
 75 | 
 76 | benchmark_impl!(
 77 |     quoted_attribute,
 78 |     encode_quoted_attribute,
 79 |     encode_quoted_attribute_to_string,
 80 |     encode_quoted_attribute_to_writer
 81 | );
 82 | 
 83 | benchmark_impl!(
 84 |     unquoted_attribute,
 85 |     encode_unquoted_attribute,
 86 |     encode_unquoted_attribute_to_string,
 87 |     encode_unquoted_attribute_to_writer
 88 | );
 89 | 
 90 | benchmark_impl!(safe, encode_safe, encode_safe_to_string, encode_safe_to_writer);
 91 | 
 92 | benchmark_impl!(script, encode_script, encode_script_to_string, encode_script_to_writer);
 93 | benchmark_impl!(
 94 |     script_single_quoted_text,
 95 |     encode_script_single_quoted_text,
 96 |     encode_script_single_quoted_text_to_string,
 97 |     encode_script_single_quoted_text_to_writer
 98 | );
 99 | benchmark_impl!(
100 |     script_double_quoted_text,
101 |     encode_script_double_quoted_text,
102 |     encode_script_double_quoted_text_to_string,
103 |     encode_script_double_quoted_text_to_writer
104 | );
105 | benchmark_impl!(
106 |     script_quoted_text,
107 |     encode_script_quoted_text,
108 |     encode_script_quoted_text_to_string,
109 |     encode_script_quoted_text_to_writer
110 | );
111 | 
112 | benchmark_impl!(style, encode_style, encode_style_to_string, encode_style_to_writer);
113 | benchmark_impl!(
114 |     style_single_quoted_text,
115 |     encode_style_single_quoted_text,
116 |     encode_style_single_quoted_text_to_string,
117 |     encode_style_single_quoted_text_to_writer
118 | );
119 | benchmark_impl!(
120 |     style_double_quoted_text,
121 |     encode_style_double_quoted_text,
122 |     encode_style_double_quoted_text_to_string,
123 |     encode_style_double_quoted_text_to_writer
124 | );
125 | benchmark_impl!(
126 |     style_quoted_text,
127 |     encode_style_quoted_text,
128 |     encode_style_quoted_text_to_string,
129 |     encode_style_quoted_text_to_writer
130 | );
131 | 
132 | benchmark_main!(
133 |     text_minimal,
134 |     text,
135 |     double_quoted_attribute,
136 |     single_quoted_attribute,
137 |     quoted_attribute,
138 |     unquoted_attribute,
139 |     safe,
140 |     script,
141 |     script_single_quoted_text,
142 |     script_double_quoted_text,
143 |     script_quoted_text,
144 |     style,
145 |     style_single_quoted_text,
146 |     style_double_quoted_text,
147 |     style_quoted_text,
148 | );
149 | 


--------------------------------------------------------------------------------
/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


--------------------------------------------------------------------------------
/src/decode/element/decode_impl.rs:
--------------------------------------------------------------------------------
  1 | macro_rules! decode_impl {
  2 |     ($l:expr; $(#[$attr: meta])* $parse_macro:ident; $(#[$decode_attr: meta])* $decode_name: ident; $(#[$decode_to_string_attr: meta])* $decode_to_string_name: ident; $(#[$decode_to_vec_attr: meta])* $decode_to_vec_name: ident; $(#[$decode_to_writer_attr: meta])* $decode_to_writer_name: ident $(;)*) => {
  3 |         $(#[$decode_attr])*
  4 |         ///
  5 |         $(#[$attr])*
  6 |         #[inline]
  7 |         pub fn $decode_name<S: ?Sized + AsRef<str>>(text: &S) -> Cow<str> {
  8 |             let text = text.as_ref();
  9 |             let text_bytes = text.as_bytes();
 10 |             let text_length = text_bytes.len();
 11 | 
 12 |             let mut p = 0;
 13 |             let mut e;
 14 | 
 15 |             let mut step = 0;
 16 | 
 17 |             let (mut v, mut start) = loop {
 18 |                 if p == text_length {
 19 |                     return Cow::from(text);
 20 |                 }
 21 | 
 22 |                 e = text_bytes[p];
 23 | 
 24 |                 $parse_macro!(e, step,
 25 |                     {
 26 |                         let mut v = Vec::with_capacity(text_length);
 27 | 
 28 |                         v.extend_from_slice(&text_bytes[..(p - ($l + 1))]);
 29 | 
 30 |                         break (v, p - $l);
 31 |                     },
 32 |                     {
 33 |                         let mut v = Vec::with_capacity(text_length);
 34 | 
 35 |                         v.extend_from_slice(&text_bytes[..(p - 1)]);
 36 | 
 37 |                         break (v, p);
 38 |                     },
 39 |                     {
 40 |                         let mut v = Vec::with_capacity(text_length);
 41 | 
 42 |                         v.extend_from_slice(&text_bytes[..(p - 3)]);
 43 | 
 44 |                         break (v, p - 2);
 45 |                     }
 46 |                 );
 47 | 
 48 |                 p += 1;
 49 |             };
 50 | 
 51 |             p += 1;
 52 | 
 53 |             for e in text_bytes[p..].iter().copied() {
 54 |                 $parse_macro!(e, step,
 55 |                     {
 56 |                         v.extend_from_slice(&text_bytes[start..(p - ($l + 1))]);
 57 |                         start = p - $l;
 58 |                     },
 59 |                     {
 60 |                         v.extend_from_slice(&text_bytes[start..(p - 1)]);
 61 |                         start = p;
 62 |                     },
 63 |                     {
 64 |                         v.extend_from_slice(&text_bytes[start..(p - 3)]);
 65 |                         start = p - 2;
 66 |                     }
 67 |                 );
 68 | 
 69 |                 p += 1;
 70 |             }
 71 | 
 72 |             v.extend_from_slice(&text_bytes[start..p]);
 73 | 
 74 |             Cow::from(unsafe { String::from_utf8_unchecked(v) })
 75 |         }
 76 | 
 77 |         $(#[$decode_to_string_attr])*
 78 |         ///
 79 |         $(#[$attr])*
 80 |         #[inline]
 81 |         pub fn $decode_to_string_name<S: AsRef<str>>(text: S, output: &mut String) -> &str {
 82 |             unsafe { from_utf8_unchecked($decode_to_vec_name(text, output.as_mut_vec())) }
 83 |         }
 84 | 
 85 |         $(#[$decode_to_vec_attr])*
 86 |         ///
 87 |         $(#[$attr])*
 88 |         #[inline]
 89 |         pub fn $decode_to_vec_name<S: AsRef<str>>(text: S, output: &mut Vec<u8>) -> &[u8] {
 90 |             let text = text.as_ref();
 91 |             let text_bytes = text.as_bytes();
 92 |             let text_length = text_bytes.len();
 93 | 
 94 |             output.reserve(text_length);
 95 | 
 96 |             let current_length = output.len();
 97 | 
 98 |             let mut start = 0;
 99 |             let mut end = 0;
100 | 
101 |             let mut step = 0;
102 | 
103 |             for e in text_bytes.iter().copied() {
104 |                 $parse_macro!(e, step,
105 |                     {
106 |                         output.extend_from_slice(&text_bytes[start..(end - ($l + 1))]);
107 |                         start = end - $l;
108 |                     },
109 |                     {
110 |                         output.extend_from_slice(&text_bytes[start..(end - 1)]);
111 |                         start = end;
112 |                     },
113 |                     {
114 |                         output.extend_from_slice(&text_bytes[start..(end - 3)]);
115 |                         start = end - 2;
116 |                     }
117 |                 );
118 | 
119 |                 end += 1;
120 |             }
121 | 
122 |             output.extend_from_slice(&text_bytes[start..end]);
123 | 
124 |             &output[current_length..]
125 |         }
126 | 
127 |         #[cfg(feature = "std")]
128 |         $(#[$decode_to_writer_attr])*
129 |         ///
130 |         $(#[$attr])*
131 |         #[inline]
132 |         pub fn $decode_to_writer_name<S: AsRef<str>, W: Write>(text: S, output: &mut W) -> Result<(), io::Error> {
133 |             let text = text.as_ref();
134 |             let text_bytes = text.as_bytes();
135 | 
136 |             let mut start = 0;
137 |             let mut end = 0;
138 | 
139 |             let mut step = 0;
140 | 
141 |             for e in text_bytes.iter().copied() {
142 |                 $parse_macro!(e, step,
143 |                     {
144 |                         output.write_all(&text_bytes[start..(end - ($l + 1))])?;
145 |                         start = end - $l;
146 |                     },
147 |                     {
148 |                         output.write_all(&text_bytes[start..(end - 1)])?;
149 |                         start = end;
150 |                     },
151 |                     {
152 |                         output.write_all(&text_bytes[start..(end - 3)])?;
153 |                         start = end - 2;
154 |                     }
155 |                 );
156 | 
157 |                 end += 1;
158 |             }
159 | 
160 |             output.write_all(&text_bytes[start..end])
161 |         }
162 |     };
163 | }
164 | 


--------------------------------------------------------------------------------
/src/decode/element/mod.rs:
--------------------------------------------------------------------------------
1 | #[macro_use]
2 | mod decode_impl;
3 | 
4 | mod script;
5 | mod style;
6 | 
7 | pub use script::*;
8 | pub use style::*;
9 | 


--------------------------------------------------------------------------------
/src/decode/element/script.rs:
--------------------------------------------------------------------------------
  1 | use alloc::{borrow::Cow, string::String, vec::Vec};
  2 | use core::str::from_utf8_unchecked;
  3 | #[cfg(feature = "std")]
  4 | use std::io::{self, Write};
  5 | 
  6 | macro_rules! parse_script {
  7 |     ($e:expr, $step:ident, $b:block, $bq:block, $bc:block $(, $($addi:expr),+)?) => {
  8 |         match $step {
  9 |             0 => {
 10 |                 match $e {
 11 |                     b'<' => $step = 1,
 12 |                     b'\\' => $step = 100,
 13 |                     _ => (),
 14 |                 }
 15 |             }
 16 |             1 => {
 17 |                 match $e {
 18 |                     b'\\' => $step = 2,
 19 |                     _ => (),
 20 |                 }
 21 |             }
 22 |             2 => {
 23 |                 match $e {
 24 |                     b'/' => $step = 3,
 25 |                     b'!' => $step = 10,
 26 |                     $($(| $addi)+ => {
 27 |                         $step = 0;
 28 |                         $bq
 29 |                     },)?
 30 |                     _ => $step = 0,
 31 |                 }
 32 |             }
 33 |             3 => {
 34 |                 match $e {
 35 |                     b's' | b'S' => $step = 4,
 36 |                     b'\\' => $step = 100,
 37 |                     _ => $step = 0,
 38 |                 }
 39 |             }
 40 |             4 => {
 41 |                 match $e {
 42 |                     b'c' | b'C' => $step = 5,
 43 |                     b'\\' => $step = 100,
 44 |                     _ => $step = 0,
 45 |                 }
 46 |             }
 47 |             5 => {
 48 |                 match $e {
 49 |                     b'r' | b'R' => $step = 6,
 50 |                     b'\\' => $step = 100,
 51 |                     _ => $step = 0,
 52 |                 }
 53 |             }
 54 |             6 => {
 55 |                 match $e {
 56 |                     b'i' | b'I' => $step = 7,
 57 |                     b'\\' => $step = 100,
 58 |                     _ => $step = 0,
 59 |                 }
 60 |             }
 61 |             7 => {
 62 |                 match $e {
 63 |                     b'p' | b'P' => $step = 8,
 64 |                     b'\\' => $step = 100,
 65 |                     _ => $step = 0,
 66 |                 }
 67 |             }
 68 |             8 => {
 69 |                 match $e {
 70 |                     b't' | b'T' => $step = 9,
 71 |                     b'\\' => $step = 100,
 72 |                     _ => $step = 0,
 73 |                 }
 74 |             }
 75 |             9 => {
 76 |                 match $e {
 77 |                     b'>' | 9..=13 | 28..=32 => {
 78 |                         $step = 0;
 79 |                         $b
 80 |                     },
 81 |                     b'\\' => $step = 100,
 82 |                     _ => $step = 0,
 83 |                 }
 84 |             }
 85 |             10 => {
 86 |                 match $e {
 87 |                     b'-' => $step = 11,
 88 |                     b'\\' => $step = 100,
 89 |                     _ => $step = 0,
 90 |                 }
 91 |             }
 92 |             11 => {
 93 |                 match $e {
 94 |                     b'-' => {
 95 |                         $step = 0;
 96 |                         $bc
 97 |                     },
 98 |                     b'\\' => $step = 100,
 99 |                     _ => $step = 0,
100 |                 }
101 |             }
102 |             100 => {
103 |                 match $e {
104 |                     b'<' => $step = 1,
105 |                      $($(| $addi)+ => {
106 |                         $step = 0;
107 |                         $bq
108 |                     },)?
109 |                     _ => $step = 0,
110 |                 }
111 |             }
112 |             _ => unreachable!(),
113 |         }
114 |     };
115 | }
116 | 
117 | macro_rules! parse_script_single_quoted_text {
118 |     ($e:expr, $step:ident, $b:block, $bq:block, $bc:block) => {
119 |         parse_script!($e, $step, $b, $bq, $bc, b'\'');
120 |     };
121 | }
122 | 
123 | macro_rules! parse_script_double_quoted_text {
124 |     ($e:expr, $step:ident, $b:block, $bq:block, $bc:block) => {
125 |         parse_script!($e, $step, $b, $bq, $bc, b'"');
126 |     };
127 | }
128 | 
129 | macro_rules! parse_script_quoted_text {
130 |     ($e:expr, $step:ident, $b:block, $bq:block, $bc:block) => {
131 |         parse_script!($e, $step, $b, $bq, $bc, b'\'', b'"');
132 |     };
133 | }
134 | 
135 | decode_impl! {
136 |     7;
137 |     /// The following substring is unescaped:
138 |     ///
139 |     /// * `<\/script>` => `</script>`
140 |     parse_script;
141 |     /// Decode text from the `<script>` element.
142 |     decode_script;
143 |     /// Write text from the `<script>` element to a mutable `String` reference and return the encoded string slice.
144 |     decode_script_to_string;
145 |     /// Write text from the `<script>` element to a mutable `Vec<u8>` reference and return the encoded data slice.
146 |     decode_script_to_vec;
147 |     /// Write text from the `<script>` element to a writer.
148 |     decode_script_to_writer;
149 | }
150 | 
151 | decode_impl! {
152 |     7;
153 |     /// The following substring and character is unescaped:
154 |     ///
155 |     /// * `<\/script>` => `</script>`
156 |     /// * `\'` => `'`
157 |     parse_script_single_quoted_text;
158 |     /// Decode text from a single quoted text in the `<script>` element.
159 |     decode_script_single_quoted_text;
160 |     /// Write text from a single quoted text in the `<script>` element to a mutable `String` reference and return the encoded string slice.
161 |     decode_script_single_quoted_text_to_string;
162 |     /// Write text from a single quoted text in the `<script>` element to a mutable `Vec<u8>` reference and return the encoded data slice.
163 |     decode_script_single_quoted_text_to_vec;
164 |     /// Write text from a single quoted text in the `<script>` element to a writer.
165 |     decode_script_single_quoted_text_to_writer;
166 | }
167 | 
168 | decode_impl! {
169 |     7;
170 |     /// The following substring and character are unescaped:
171 |     ///
172 |     /// * `<\/script>` => `</script>`
173 |     /// * `\"` => `"`
174 |     parse_script_double_quoted_text;
175 |     /// Decode text from a double quoted text in the `<script>` element.
176 |     decode_script_double_quoted_text;
177 |     /// Write text from a double quoted text in the `<script>` element to a mutable `String` reference and return the encoded string slice.
178 |     decode_script_double_quoted_text_to_string;
179 |     /// Write text from a double quoted text in the `<script>` element to a mutable `Vec<u8>` reference and return the encoded data slice.
180 |     decode_script_double_quoted_text_to_vec;
181 |     /// Write text from a double quoted text in the `<script>` element to a writer.
182 |     decode_script_double_quoted_text_to_writer;
183 | }
184 | 
185 | decode_impl! {
186 |     7;
187 |     /// The following substring and characters are unescaped:
188 |     ///
189 |     /// * `<\/script>` => `</script>`
190 |     /// * `\"` => `"`
191 |     /// * `\'` => `'`
192 |     parse_script_quoted_text;
193 |     /// Decode text from a quoted text in the `<script>` element.
194 |     decode_script_quoted_text;
195 |     /// Write text from a quoted text in the `<script>` element to a mutable `String` reference and return the encoded string slice.
196 |     decode_script_quoted_text_to_string;
197 |     /// Write text from a quoted text in the `<script>` element to a mutable `Vec<u8>` reference and return the encoded data slice.
198 |     decode_script_quoted_text_to_vec;
199 |     /// Write text from a quoted text in the `<script>` element to a writer.
200 |     decode_script_quoted_text_to_writer;
201 | }
202 | 


--------------------------------------------------------------------------------
/src/decode/element/style.rs:
--------------------------------------------------------------------------------
  1 | use alloc::{borrow::Cow, string::String, vec::Vec};
  2 | use core::str::from_utf8_unchecked;
  3 | #[cfg(feature = "std")]
  4 | use std::io::{self, Write};
  5 | 
  6 | macro_rules! parse_style {
  7 |     ($e:expr, $step:ident, $b:block, $bq:block, $bc:block $(, $($addi:expr),+)?) => {
  8 |         match $step {
  9 |             0 => {
 10 |                 match $e {
 11 |                     b'<' => $step = 1,
 12 |                     b'\\' => $step = 100,
 13 |                     _ => (),
 14 |                 }
 15 |             }
 16 |             1 => {
 17 |                 match $e {
 18 |                     b'\\' => $step = 2,
 19 |                     _ => (),
 20 |                 }
 21 |             }
 22 |             2 => {
 23 |                 match $e {
 24 |                     b'/' => $step = 3,
 25 |                     b'!' => $step = 10,
 26 |                     $($(| $addi)+ => {
 27 |                         $step = 0;
 28 |                         $bq
 29 |                     },)?
 30 |                     _ => $step = 0,
 31 |                 }
 32 |             }
 33 |             3 => {
 34 |                 match $e {
 35 |                     b's' | b'S' => $step = 4,
 36 |                     b'\\' => $step = 100,
 37 |                     _ => $step = 0,
 38 |                 }
 39 |             }
 40 |             4 => {
 41 |                 match $e {
 42 |                     b't' | b'T' => $step = 5,
 43 |                     b'\\' => $step = 100,
 44 |                     _ => $step = 0,
 45 |                 }
 46 |             }
 47 |             5 => {
 48 |                 match $e {
 49 |                     b'y' | b'Y' => $step = 6,
 50 |                     b'\\' => $step = 100,
 51 |                     _ => $step = 0,
 52 |                 }
 53 |             }
 54 |             6 => {
 55 |                 match $e {
 56 |                     b'l' | b'L' => $step = 7,
 57 |                     b'\\' => $step = 100,
 58 |                     _ => $step = 0,
 59 |                 }
 60 |             }
 61 |             7 => {
 62 |                 match $e {
 63 |                     b'e' | b'E' => $step = 8,
 64 |                     b'\\' => $step = 100,
 65 |                     _ => $step = 0,
 66 |                 }
 67 |             }
 68 |             8 => {
 69 |                 match $e {
 70 |                     b'>' | 9..=13 | 28..=32 => {
 71 |                         $step = 0;
 72 |                         $b
 73 |                     },
 74 |                     b'\\' => $step = 100,
 75 |                     _ => $step = 0,
 76 |                 }
 77 |             }
 78 |             10 => {
 79 |                 match $e {
 80 |                     b'-' => $step = 11,
 81 |                     b'\\' => $step = 100,
 82 |                     _ => $step = 0,
 83 |                 }
 84 |             }
 85 |             11 => {
 86 |                 match $e {
 87 |                     b'-' => {
 88 |                         $step = 0;
 89 |                         $bc
 90 |                     },
 91 |                     b'\\' => $step = 100,
 92 |                     _ => $step = 0,
 93 |                 }
 94 |             }
 95 |             100 => {
 96 |                 match $e {
 97 |                     b'<' => $step = 1,
 98 |                      $($(| $addi)+ => {
 99 |                         $step = 0;
100 |                         $bq
101 |                     },)?
102 |                     _ => $step = 0,
103 |                 }
104 |             }
105 |             _ => unreachable!(),
106 |         }
107 |     };
108 | }
109 | 
110 | macro_rules! parse_style_single_quoted_text {
111 |     ($e:expr, $step:ident, $b:block, $bq:block, $bc:block) => {
112 |         parse_style!($e, $step, $b, $bq, $bc, b'\'');
113 |     };
114 | }
115 | 
116 | macro_rules! parse_style_double_quoted_text {
117 |     ($e:expr, $step:ident, $b:block, $bq:block, $bc:block) => {
118 |         parse_style!($e, $step, $b, $bq, $bc, b'"');
119 |     };
120 | }
121 | 
122 | macro_rules! parse_style_quoted_text {
123 |     ($e:expr, $step:ident, $b:block, $bq:block, $bc:block) => {
124 |         parse_style!($e, $step, $b, $bq, $bc, b'\'', b'"');
125 |     };
126 | }
127 | 
128 | decode_impl! {
129 |     6;
130 |     /// The following substring is unescaped:
131 |     ///
132 |     /// * `<\/style>` => `</style>`
133 |     parse_style;
134 |     /// Decode text from the `<style>` element.
135 |     decode_style;
136 |     /// Write text from the `<style>` element to a mutable `String` reference and return the encoded string slice.
137 |     decode_style_to_string;
138 |     /// Write text from the `<style>` element to a mutable `Vec<u8>` reference and return the encoded data slice.
139 |     decode_style_to_vec;
140 |     /// Write text from the `<style>` element to a writer.
141 |     decode_style_to_writer;
142 | }
143 | 
144 | decode_impl! {
145 |     6;
146 |     /// The following substring and character is unescaped:
147 |     ///
148 |     /// * `<\/style>` => `</style>`
149 |     /// * `\'` => `'`
150 |     parse_style_single_quoted_text;
151 |     /// Decode text from a single quoted text in the `<style>` element.
152 |     decode_style_single_quoted_text;
153 |     /// Write text from a single quoted text in the `<style>` element to a mutable `String` reference and return the encoded string slice.
154 |     decode_style_single_quoted_text_to_string;
155 |     /// Write text from a single quoted text in the `<style>` element to a mutable `Vec<u8>` reference and return the encoded data slice.
156 |     decode_style_single_quoted_text_to_vec;
157 |     /// Write text from a single quoted text in the `<style>` element to a writer.
158 |     decode_style_single_quoted_text_to_writer;
159 | }
160 | 
161 | decode_impl! {
162 |     6;
163 |     /// The following substring and character are unescaped:
164 |     ///
165 |     /// * `<\/style>` => `</style>`
166 |     /// * `\"` => `"`
167 |     parse_style_double_quoted_text;
168 |     /// Decode text from a double quoted text in the `<style>` element.
169 |     decode_style_double_quoted_text;
170 |     /// Write text from a double quoted text in the `<style>` element to a mutable `String` reference and return the encoded string slice.
171 |     decode_style_double_quoted_text_to_string;
172 |     /// Write text from a double quoted text in the `<style>` element to a mutable `Vec<u8>` reference and return the encoded data slice.
173 |     decode_style_double_quoted_text_to_vec;
174 |     /// Write text from a double quoted text in the `<style>` element to a writer.
175 |     decode_style_double_quoted_text_to_writer;
176 | }
177 | 
178 | decode_impl! {
179 |     6;
180 |     /// The following substring and characters are unescaped:
181 |     ///
182 |     /// * `<\/style>` => `</style>`
183 |     /// * `\"` => `"`
184 |     /// * `\'` => `'`
185 |     parse_style_quoted_text;
186 |     /// Decode text from a quoted text in the `<style>` element.
187 |     decode_style_quoted_text;
188 |     /// Write text from a quoted text in the `<style>` element to a mutable `String` reference and return the encoded string slice.
189 |     decode_style_quoted_text_to_string;
190 |     /// Write text from a quoted text in the `<style>` element to a mutable `Vec<u8>` reference and return the encoded data slice.
191 |     decode_style_quoted_text_to_vec;
192 |     /// Write text from a quoted text in the `<style>` element to a writer.
193 |     decode_style_quoted_text_to_writer;
194 | }
195 | 


--------------------------------------------------------------------------------
/src/decode/html_entity/mod.rs:
--------------------------------------------------------------------------------
  1 | mod tables;
  2 | 
  3 | use alloc::{borrow::Cow, string::String, vec::Vec};
  4 | use core::{convert::TryFrom, str::from_utf8_unchecked};
  5 | #[cfg(feature = "std")]
  6 | use std::io::{self, Write};
  7 | 
  8 | pub use tables::*;
  9 | 
 10 | use crate::functions::*;
 11 | 
 12 | /// Decode html entities in a given string.
 13 | pub fn decode_html_entities<S: ?Sized + AsRef<str>>(text: &S) -> Cow<str> {
 14 |     let text = text.as_ref();
 15 |     let text_bytes = text.as_bytes();
 16 |     let text_length = text_bytes.len();
 17 | 
 18 |     let mut p = 0;
 19 |     let mut ep = 0;
 20 |     let mut e;
 21 | 
 22 |     let mut step = 0;
 23 | 
 24 |     let (mut v, mut start) = loop {
 25 |         if p == text_length {
 26 |             return Cow::from(text);
 27 |         }
 28 | 
 29 |         e = text_bytes[p];
 30 | 
 31 |         match step {
 32 |             0 => {
 33 |                 if e == b'&' {
 34 |                     step = 1;
 35 |                     ep = p;
 36 |                 }
 37 |             },
 38 |             1 => {
 39 |                 match e {
 40 |                     b'#' => {
 41 |                         step = 3;
 42 |                     },
 43 |                     b';' => {
 44 |                         // incorrect
 45 |                         step = 0;
 46 |                     },
 47 |                     _ => {
 48 |                         step = 2;
 49 |                     },
 50 |                 }
 51 |             },
 52 |             2 => {
 53 |                 if e == b';' {
 54 |                     // named
 55 |                     let mut v = Vec::with_capacity(text_length);
 56 | 
 57 |                     v.extend_from_slice(&text_bytes[..ep]);
 58 | 
 59 |                     let name = &text_bytes[(ep + 1)..p];
 60 | 
 61 |                     match NAMED_ENTITIES.binary_search_by(|(t_name, _)| t_name.cmp(&name)) {
 62 |                         Ok(index) => {
 63 |                             v.extend_from_slice(NAMED_ENTITIES[index].1.as_bytes());
 64 |                             break (v, p + 1);
 65 |                         },
 66 |                         Err(_) => break (v, ep),
 67 |                     }
 68 |                 }
 69 |             },
 70 |             3 => {
 71 |                 match e {
 72 |                     b'x' | b'X' => {
 73 |                         step = 5;
 74 |                     },
 75 |                     b';' => {
 76 |                         // incorrect
 77 |                         step = 0;
 78 |                     },
 79 |                     _ => step = 4,
 80 |                 }
 81 |             },
 82 |             4 => {
 83 |                 if e == b';' {
 84 |                     // numeric
 85 |                     let mut v = Vec::with_capacity(text_length);
 86 | 
 87 |                     v.extend_from_slice(&text_bytes[..ep]);
 88 | 
 89 |                     let number = unsafe { text.get_unchecked((ep + 2)..p) };
 90 | 
 91 |                     match number.parse::<u32>() {
 92 |                         Ok(number) => match char::try_from(number) {
 93 |                             Ok(c) => {
 94 |                                 write_char_to_vec(c, &mut v);
 95 |                                 break (v, p + 1);
 96 |                             },
 97 |                             Err(_) => break (v, ep),
 98 |                         },
 99 |                         Err(_) => break (v, ep),
100 |                     }
101 |                 }
102 |             },
103 |             5 => {
104 |                 match e {
105 |                     b';' => {
106 |                         // incorrect
107 |                         step = 0;
108 |                     },
109 |                     _ => step = 6,
110 |                 }
111 |             },
112 |             6 => {
113 |                 if e == b';' {
114 |                     // hex
115 |                     let mut v = Vec::with_capacity(text_length);
116 | 
117 |                     v.extend_from_slice(&text_bytes[..ep]);
118 | 
119 |                     let hex = unsafe { text.get_unchecked((ep + 3)..p) };
120 | 
121 |                     match u32::from_str_radix(hex, 16) {
122 |                         Ok(number) => match char::try_from(number) {
123 |                             Ok(c) => {
124 |                                 write_char_to_vec(c, &mut v);
125 |                                 break (v, p + 1);
126 |                             },
127 |                             Err(_) => break (v, ep),
128 |                         },
129 |                         Err(_) => break (v, ep),
130 |                     }
131 |                 }
132 |             },
133 |             _ => unreachable!(),
134 |         }
135 | 
136 |         p += 1;
137 |     };
138 | 
139 |     p += 1;
140 | 
141 |     step = 0;
142 | 
143 |     for e in text_bytes[p..].iter().copied() {
144 |         match step {
145 |             0 => {
146 |                 if e == b'&' {
147 |                     step = 1;
148 |                     ep = p;
149 |                 }
150 |             },
151 |             1 => {
152 |                 match e {
153 |                     b'#' => {
154 |                         step = 3;
155 |                     },
156 |                     b';' => {
157 |                         // incorrect
158 |                         step = 0;
159 |                     },
160 |                     _ => {
161 |                         step = 2;
162 |                     },
163 |                 }
164 |             },
165 |             2 => {
166 |                 if e == b';' {
167 |                     // named
168 |                     step = 0;
169 | 
170 |                     let name = &text_bytes[(ep + 1)..p];
171 | 
172 |                     if let Ok(index) =
173 |                         NAMED_ENTITIES.binary_search_by(|(t_name, _)| t_name.cmp(&name))
174 |                     {
175 |                         v.extend_from_slice(&text_bytes[start..ep]);
176 |                         start = p + 1;
177 |                         v.extend_from_slice(NAMED_ENTITIES[index].1.as_bytes());
178 |                     }
179 |                 }
180 |             },
181 |             3 => {
182 |                 match e {
183 |                     b'x' | b'X' => {
184 |                         step = 5;
185 |                     },
186 |                     b';' => {
187 |                         // incorrect
188 |                         step = 0;
189 |                     },
190 |                     _ => step = 4,
191 |                 }
192 |             },
193 |             4 => {
194 |                 if e == b';' {
195 |                     // numeric
196 |                     step = 0;
197 | 
198 |                     let number = unsafe { text.get_unchecked((ep + 2)..p) };
199 | 
200 |                     if let Ok(number) = number.parse::<u32>() {
201 |                         if let Ok(c) = char::try_from(number) {
202 |                             v.extend_from_slice(&text_bytes[start..ep]);
203 |                             start = p + 1;
204 |                             write_char_to_vec(c, &mut v);
205 |                         }
206 |                     }
207 |                 }
208 |             },
209 |             5 => {
210 |                 match e {
211 |                     b';' => {
212 |                         // incorrect
213 |                         step = 0;
214 |                     },
215 |                     _ => step = 6,
216 |                 }
217 |             },
218 |             6 => {
219 |                 if e == b';' {
220 |                     // hex
221 |                     step = 0;
222 | 
223 |                     let hex = unsafe { text.get_unchecked((ep + 3)..p) };
224 | 
225 |                     if let Ok(number) = u32::from_str_radix(hex, 16) {
226 |                         if let Ok(c) = char::try_from(number) {
227 |                             v.extend_from_slice(&text_bytes[start..ep]);
228 |                             start = p + 1;
229 |                             write_char_to_vec(c, &mut v);
230 |                         }
231 |                     }
232 |                 }
233 |             },
234 |             _ => unreachable!(),
235 |         }
236 | 
237 |         p += 1;
238 |     }
239 | 
240 |     v.extend_from_slice(&text_bytes[start..p]);
241 | 
242 |     Cow::from(unsafe { String::from_utf8_unchecked(v) })
243 | }
244 | 
245 | /// Decode html entities in a given string to a mutable `String` reference and return the decoded string slice.
246 | pub fn decode_html_entities_to_string<S: AsRef<str>>(text: S, output: &mut String) -> &str {
247 |     unsafe { from_utf8_unchecked(decode_html_entities_to_vec(text, output.as_mut_vec())) }
248 | }
249 | 
250 | /// Decode html entities in a given string to a mutable `Vec<u8>` reference and return the decoded data slice.
251 | pub fn decode_html_entities_to_vec<S: AsRef<str>>(text: S, output: &mut Vec<u8>) -> &[u8] {
252 |     let text = text.as_ref();
253 |     let text_bytes = text.as_bytes();
254 |     let text_length = text_bytes.len();
255 | 
256 |     output.reserve(text_length);
257 | 
258 |     let current_length = output.len();
259 | 
260 |     let mut start = 0;
261 |     let mut end = 0;
262 |     let mut ep = 0;
263 | 
264 |     let mut step = 0;
265 | 
266 |     for e in text_bytes.iter().copied() {
267 |         match step {
268 |             0 => {
269 |                 if e == b'&' {
270 |                     step = 1;
271 |                     ep = end;
272 |                 }
273 |             },
274 |             1 => {
275 |                 match e {
276 |                     b'#' => {
277 |                         step = 3;
278 |                     },
279 |                     b';' => {
280 |                         // incorrect
281 |                         step = 0;
282 |                     },
283 |                     _ => {
284 |                         step = 2;
285 |                     },
286 |                 }
287 |             },
288 |             2 => {
289 |                 if e == b';' {
290 |                     // named
291 |                     step = 0;
292 | 
293 |                     let name = &text_bytes[(ep + 1)..end];
294 | 
295 |                     if let Ok(index) =
296 |                         NAMED_ENTITIES.binary_search_by(|(t_name, _)| t_name.cmp(&name))
297 |                     {
298 |                         output.extend_from_slice(&text_bytes[start..ep]);
299 |                         start = end + 1;
300 |                         output.extend_from_slice(NAMED_ENTITIES[index].1.as_bytes());
301 |                     }
302 |                 }
303 |             },
304 |             3 => {
305 |                 match e {
306 |                     b'x' | b'X' => {
307 |                         step = 5;
308 |                     },
309 |                     b';' => {
310 |                         // incorrect
311 |                         step = 0;
312 |                     },
313 |                     _ => step = 4,
314 |                 }
315 |             },
316 |             4 => {
317 |                 if e == b';' {
318 |                     // numeric
319 |                     step = 0;
320 | 
321 |                     let number = unsafe { text.get_unchecked((ep + 2)..end) };
322 | 
323 |                     if let Ok(number) = number.parse::<u32>() {
324 |                         if let Ok(c) = char::try_from(number) {
325 |                             output.extend_from_slice(&text_bytes[start..ep]);
326 |                             start = end + 1;
327 |                             write_char_to_vec(c, output);
328 |                         }
329 |                     }
330 |                 }
331 |             },
332 |             5 => {
333 |                 match e {
334 |                     b';' => {
335 |                         // incorrect
336 |                         step = 0;
337 |                     },
338 |                     _ => step = 6,
339 |                 }
340 |             },
341 |             6 => {
342 |                 if e == b';' {
343 |                     // hex
344 |                     step = 0;
345 | 
346 |                     let hex = unsafe { text.get_unchecked((ep + 3)..end) };
347 | 
348 |                     if let Ok(number) = u32::from_str_radix(hex, 16) {
349 |                         if let Ok(c) = char::try_from(number) {
350 |                             output.extend_from_slice(&text_bytes[start..ep]);
351 |                             start = end + 1;
352 |                             write_char_to_vec(c, output);
353 |                         }
354 |                     }
355 |                 }
356 |             },
357 |             _ => unreachable!(),
358 |         }
359 | 
360 |         end += 1;
361 |     }
362 | 
363 |     output.extend_from_slice(&text_bytes[start..end]);
364 | 
365 |     &output[current_length..]
366 | }
367 | 
368 | #[cfg(feature = "std")]
369 | /// Decode html entities in a given string to a writer.
370 | pub fn decode_html_entities_to_writer<S: AsRef<str>, W: Write>(
371 |     text: S,
372 |     output: &mut W,
373 | ) -> Result<(), io::Error> {
374 |     let text = text.as_ref();
375 |     let text_bytes = text.as_bytes();
376 | 
377 |     let mut start = 0;
378 |     let mut end = 0;
379 |     let mut ep = 0;
380 | 
381 |     let mut step = 0;
382 | 
383 |     for e in text_bytes.iter().copied() {
384 |         match step {
385 |             0 => {
386 |                 if e == b'&' {
387 |                     step = 1;
388 |                     ep = end;
389 |                 }
390 |             },
391 |             1 => {
392 |                 match e {
393 |                     b'#' => {
394 |                         step = 3;
395 |                     },
396 |                     b';' => {
397 |                         // incorrect
398 |                         step = 0;
399 |                     },
400 |                     _ => {
401 |                         step = 2;
402 |                     },
403 |                 }
404 |             },
405 |             2 => {
406 |                 if e == b';' {
407 |                     // named
408 |                     step = 0;
409 | 
410 |                     let name = &text_bytes[(ep + 1)..end];
411 | 
412 |                     if let Ok(index) =
413 |                         NAMED_ENTITIES.binary_search_by(|(t_name, _)| t_name.cmp(&name))
414 |                     {
415 |                         output.write_all(&text_bytes[start..ep])?;
416 |                         start = end + 1;
417 |                         output.write_all(NAMED_ENTITIES[index].1.as_bytes())?;
418 |                     }
419 |                 }
420 |             },
421 |             3 => {
422 |                 match e {
423 |                     b'x' | b'X' => {
424 |                         step = 5;
425 |                     },
426 |                     b';' => {
427 |                         // incorrect
428 |                         step = 0;
429 |                     },
430 |                     _ => step = 4,
431 |                 }
432 |             },
433 |             4 => {
434 |                 if e == b';' {
435 |                     // numeric
436 |                     step = 0;
437 | 
438 |                     let number = unsafe { text.get_unchecked((ep + 2)..end) };
439 | 
440 |                     if let Ok(number) = number.parse::<u32>() {
441 |                         if let Ok(c) = char::try_from(number) {
442 |                             output.write_all(&text_bytes[start..ep])?;
443 |                             start = end + 1;
444 |                             write_char_to_writer(c, output)?;
445 |                         }
446 |                     }
447 |                 }
448 |             },
449 |             5 => {
450 |                 match e {
451 |                     b';' => {
452 |                         // incorrect
453 |                         step = 0;
454 |                     },
455 |                     _ => step = 6,
456 |                 }
457 |             },
458 |             6 => {
459 |                 if e == b';' {
460 |                     // hex
461 |                     step = 0;
462 | 
463 |                     let hex = unsafe { text.get_unchecked((ep + 3)..end) };
464 | 
465 |                     if let Ok(number) = u32::from_str_radix(hex, 16) {
466 |                         if let Ok(c) = char::try_from(number) {
467 |                             output.write_all(&text_bytes[start..ep])?;
468 |                             start = end + 1;
469 |                             write_char_to_writer(c, output)?;
470 |                         }
471 |                     }
472 |                 }
473 |             },
474 |             _ => unreachable!(),
475 |         }
476 | 
477 |         end += 1;
478 |     }
479 | 
480 |     output.write_all(&text_bytes[start..end])
481 | }
482 | 


--------------------------------------------------------------------------------
/src/decode/html_entity/tables.rs:
--------------------------------------------------------------------------------
   1 | /// The table of HTML named entities ordered by the names.
   2 | ///
   3 | /// Source: https://html.spec.whatwg.org/entities.json
   4 | pub static NAMED_ENTITIES: [(&[u8], &str); 2125] = [
   5 |     (b"AElig", "\u{00C6}"),
   6 |     (b"AMP", "\u{0026}"),
   7 |     (b"Aacute", "\u{00C1}"),
   8 |     (b"Abreve", "\u{0102}"),
   9 |     (b"Acirc", "\u{00C2}"),
  10 |     (b"Acy", "\u{0410}"),
  11 |     (b"Afr", "\u{1D504}"),
  12 |     (b"Agrave", "\u{00C0}"),
  13 |     (b"Alpha", "\u{0391}"),
  14 |     (b"Amacr", "\u{0100}"),
  15 |     (b"And", "\u{2A53}"),
  16 |     (b"Aogon", "\u{0104}"),
  17 |     (b"Aopf", "\u{1D538}"),
  18 |     (b"ApplyFunction", "\u{2061}"),
  19 |     (b"Aring", "\u{00C5}"),
  20 |     (b"Ascr", "\u{1D49C}"),
  21 |     (b"Assign", "\u{2254}"),
  22 |     (b"Atilde", "\u{00C3}"),
  23 |     (b"Auml", "\u{00C4}"),
  24 |     (b"Backslash", "\u{2216}"),
  25 |     (b"Barv", "\u{2AE7}"),
  26 |     (b"Barwed", "\u{2306}"),
  27 |     (b"Bcy", "\u{0411}"),
  28 |     (b"Because", "\u{2235}"),
  29 |     (b"Bernoullis", "\u{212C}"),
  30 |     (b"Beta", "\u{0392}"),
  31 |     (b"Bfr", "\u{1D505}"),
  32 |     (b"Bopf", "\u{1D539}"),
  33 |     (b"Breve", "\u{02D8}"),
  34 |     (b"Bscr", "\u{212C}"),
  35 |     (b"Bumpeq", "\u{224E}"),
  36 |     (b"CHcy", "\u{0427}"),
  37 |     (b"COPY", "\u{00A9}"),
  38 |     (b"Cacute", "\u{0106}"),
  39 |     (b"Cap", "\u{22D2}"),
  40 |     (b"CapitalDifferentialD", "\u{2145}"),
  41 |     (b"Cayleys", "\u{212D}"),
  42 |     (b"Ccaron", "\u{010C}"),
  43 |     (b"Ccedil", "\u{00C7}"),
  44 |     (b"Ccirc", "\u{0108}"),
  45 |     (b"Cconint", "\u{2230}"),
  46 |     (b"Cdot", "\u{010A}"),
  47 |     (b"Cedilla", "\u{00B8}"),
  48 |     (b"CenterDot", "\u{00B7}"),
  49 |     (b"Cfr", "\u{212D}"),
  50 |     (b"Chi", "\u{03A7}"),
  51 |     (b"CircleDot", "\u{2299}"),
  52 |     (b"CircleMinus", "\u{2296}"),
  53 |     (b"CirclePlus", "\u{2295}"),
  54 |     (b"CircleTimes", "\u{2297}"),
  55 |     (b"ClockwiseContourIntegral", "\u{2232}"),
  56 |     (b"CloseCurlyDoubleQuote", "\u{201D}"),
  57 |     (b"CloseCurlyQuote", "\u{2019}"),
  58 |     (b"Colon", "\u{2237}"),
  59 |     (b"Colone", "\u{2A74}"),
  60 |     (b"Congruent", "\u{2261}"),
  61 |     (b"Conint", "\u{222F}"),
  62 |     (b"ContourIntegral", "\u{222E}"),
  63 |     (b"Copf", "\u{2102}"),
  64 |     (b"Coproduct", "\u{2210}"),
  65 |     (b"CounterClockwiseContourIntegral", "\u{2233}"),
  66 |     (b"Cross", "\u{2A2F}"),
  67 |     (b"Cscr", "\u{1D49E}"),
  68 |     (b"Cup", "\u{22D3}"),
  69 |     (b"CupCap", "\u{224D}"),
  70 |     (b"DD", "\u{2145}"),
  71 |     (b"DDotrahd", "\u{2911}"),
  72 |     (b"DJcy", "\u{0402}"),
  73 |     (b"DScy", "\u{0405}"),
  74 |     (b"DZcy", "\u{040F}"),
  75 |     (b"Dagger", "\u{2021}"),
  76 |     (b"Darr", "\u{21A1}"),
  77 |     (b"Dashv", "\u{2AE4}"),
  78 |     (b"Dcaron", "\u{010E}"),
  79 |     (b"Dcy", "\u{0414}"),
  80 |     (b"Del", "\u{2207}"),
  81 |     (b"Delta", "\u{0394}"),
  82 |     (b"Dfr", "\u{1D507}"),
  83 |     (b"DiacriticalAcute", "\u{00B4}"),
  84 |     (b"DiacriticalDot", "\u{02D9}"),
  85 |     (b"DiacriticalDoubleAcute", "\u{02DD}"),
  86 |     (b"DiacriticalGrave", "\u{0060}"),
  87 |     (b"DiacriticalTilde", "\u{02DC}"),
  88 |     (b"Diamond", "\u{22C4}"),
  89 |     (b"DifferentialD", "\u{2146}"),
  90 |     (b"Dopf", "\u{1D53B}"),
  91 |     (b"Dot", "\u{00A8}"),
  92 |     (b"DotDot", "\u{20DC}"),
  93 |     (b"DotEqual", "\u{2250}"),
  94 |     (b"DoubleContourIntegral", "\u{222F}"),
  95 |     (b"DoubleDot", "\u{00A8}"),
  96 |     (b"DoubleDownArrow", "\u{21D3}"),
  97 |     (b"DoubleLeftArrow", "\u{21D0}"),
  98 |     (b"DoubleLeftRightArrow", "\u{21D4}"),
  99 |     (b"DoubleLeftTee", "\u{2AE4}"),
 100 |     (b"DoubleLongLeftArrow", "\u{27F8}"),
 101 |     (b"DoubleLongLeftRightArrow", "\u{27FA}"),
 102 |     (b"DoubleLongRightArrow", "\u{27F9}"),
 103 |     (b"DoubleRightArrow", "\u{21D2}"),
 104 |     (b"DoubleRightTee", "\u{22A8}"),
 105 |     (b"DoubleUpArrow", "\u{21D1}"),
 106 |     (b"DoubleUpDownArrow", "\u{21D5}"),
 107 |     (b"DoubleVerticalBar", "\u{2225}"),
 108 |     (b"DownArrow", "\u{2193}"),
 109 |     (b"DownArrowBar", "\u{2913}"),
 110 |     (b"DownArrowUpArrow", "\u{21F5}"),
 111 |     (b"DownBreve", "\u{0311}"),
 112 |     (b"DownLeftRightVector", "\u{2950}"),
 113 |     (b"DownLeftTeeVector", "\u{295E}"),
 114 |     (b"DownLeftVector", "\u{21BD}"),
 115 |     (b"DownLeftVectorBar", "\u{2956}"),
 116 |     (b"DownRightTeeVector", "\u{295F}"),
 117 |     (b"DownRightVector", "\u{21C1}"),
 118 |     (b"DownRightVectorBar", "\u{2957}"),
 119 |     (b"DownTee", "\u{22A4}"),
 120 |     (b"DownTeeArrow", "\u{21A7}"),
 121 |     (b"Downarrow", "\u{21D3}"),
 122 |     (b"Dscr", "\u{1D49F}"),
 123 |     (b"Dstrok", "\u{0110}"),
 124 |     (b"ENG", "\u{014A}"),
 125 |     (b"ETH", "\u{00D0}"),
 126 |     (b"Eacute", "\u{00C9}"),
 127 |     (b"Ecaron", "\u{011A}"),
 128 |     (b"Ecirc", "\u{00CA}"),
 129 |     (b"Ecy", "\u{042D}"),
 130 |     (b"Edot", "\u{0116}"),
 131 |     (b"Efr", "\u{1D508}"),
 132 |     (b"Egrave", "\u{00C8}"),
 133 |     (b"Element", "\u{2208}"),
 134 |     (b"Emacr", "\u{0112}"),
 135 |     (b"EmptySmallSquare", "\u{25FB}"),
 136 |     (b"EmptyVerySmallSquare", "\u{25AB}"),
 137 |     (b"Eogon", "\u{0118}"),
 138 |     (b"Eopf", "\u{1D53C}"),
 139 |     (b"Epsilon", "\u{0395}"),
 140 |     (b"Equal", "\u{2A75}"),
 141 |     (b"EqualTilde", "\u{2242}"),
 142 |     (b"Equilibrium", "\u{21CC}"),
 143 |     (b"Escr", "\u{2130}"),
 144 |     (b"Esim", "\u{2A73}"),
 145 |     (b"Eta", "\u{0397}"),
 146 |     (b"Euml", "\u{00CB}"),
 147 |     (b"Exists", "\u{2203}"),
 148 |     (b"ExponentialE", "\u{2147}"),
 149 |     (b"Fcy", "\u{0424}"),
 150 |     (b"Ffr", "\u{1D509}"),
 151 |     (b"FilledSmallSquare", "\u{25FC}"),
 152 |     (b"FilledVerySmallSquare", "\u{25AA}"),
 153 |     (b"Fopf", "\u{1D53D}"),
 154 |     (b"ForAll", "\u{2200}"),
 155 |     (b"Fouriertrf", "\u{2131}"),
 156 |     (b"Fscr", "\u{2131}"),
 157 |     (b"GJcy", "\u{0403}"),
 158 |     (b"GT", "\u{003E}"),
 159 |     (b"Gamma", "\u{0393}"),
 160 |     (b"Gammad", "\u{03DC}"),
 161 |     (b"Gbreve", "\u{011E}"),
 162 |     (b"Gcedil", "\u{0122}"),
 163 |     (b"Gcirc", "\u{011C}"),
 164 |     (b"Gcy", "\u{0413}"),
 165 |     (b"Gdot", "\u{0120}"),
 166 |     (b"Gfr", "\u{1D50A}"),
 167 |     (b"Gg", "\u{22D9}"),
 168 |     (b"Gopf", "\u{1D53E}"),
 169 |     (b"GreaterEqual", "\u{2265}"),
 170 |     (b"GreaterEqualLess", "\u{22DB}"),
 171 |     (b"GreaterFullEqual", "\u{2267}"),
 172 |     (b"GreaterGreater", "\u{2AA2}"),
 173 |     (b"GreaterLess", "\u{2277}"),
 174 |     (b"GreaterSlantEqual", "\u{2A7E}"),
 175 |     (b"GreaterTilde", "\u{2273}"),
 176 |     (b"Gscr", "\u{1D4A2}"),
 177 |     (b"Gt", "\u{226B}"),
 178 |     (b"HARDcy", "\u{042A}"),
 179 |     (b"Hacek", "\u{02C7}"),
 180 |     (b"Hat", "\u{005E}"),
 181 |     (b"Hcirc", "\u{0124}"),
 182 |     (b"Hfr", "\u{210C}"),
 183 |     (b"HilbertSpace", "\u{210B}"),
 184 |     (b"Hopf", "\u{210D}"),
 185 |     (b"HorizontalLine", "\u{2500}"),
 186 |     (b"Hscr", "\u{210B}"),
 187 |     (b"Hstrok", "\u{0126}"),
 188 |     (b"HumpDownHump", "\u{224E}"),
 189 |     (b"HumpEqual", "\u{224F}"),
 190 |     (b"IEcy", "\u{0415}"),
 191 |     (b"IJlig", "\u{0132}"),
 192 |     (b"IOcy", "\u{0401}"),
 193 |     (b"Iacute", "\u{00CD}"),
 194 |     (b"Icirc", "\u{00CE}"),
 195 |     (b"Icy", "\u{0418}"),
 196 |     (b"Idot", "\u{0130}"),
 197 |     (b"Ifr", "\u{2111}"),
 198 |     (b"Igrave", "\u{00CC}"),
 199 |     (b"Im", "\u{2111}"),
 200 |     (b"Imacr", "\u{012A}"),
 201 |     (b"ImaginaryI", "\u{2148}"),
 202 |     (b"Implies", "\u{21D2}"),
 203 |     (b"Int", "\u{222C}"),
 204 |     (b"Integral", "\u{222B}"),
 205 |     (b"Intersection", "\u{22C2}"),
 206 |     (b"InvisibleComma", "\u{2063}"),
 207 |     (b"InvisibleTimes", "\u{2062}"),
 208 |     (b"Iogon", "\u{012E}"),
 209 |     (b"Iopf", "\u{1D540}"),
 210 |     (b"Iota", "\u{0399}"),
 211 |     (b"Iscr", "\u{2110}"),
 212 |     (b"Itilde", "\u{0128}"),
 213 |     (b"Iukcy", "\u{0406}"),
 214 |     (b"Iuml", "\u{00CF}"),
 215 |     (b"Jcirc", "\u{0134}"),
 216 |     (b"Jcy", "\u{0419}"),
 217 |     (b"Jfr", "\u{1D50D}"),
 218 |     (b"Jopf", "\u{1D541}"),
 219 |     (b"Jscr", "\u{1D4A5}"),
 220 |     (b"Jsercy", "\u{0408}"),
 221 |     (b"Jukcy", "\u{0404}"),
 222 |     (b"KHcy", "\u{0425}"),
 223 |     (b"KJcy", "\u{040C}"),
 224 |     (b"Kappa", "\u{039A}"),
 225 |     (b"Kcedil", "\u{0136}"),
 226 |     (b"Kcy", "\u{041A}"),
 227 |     (b"Kfr", "\u{1D50E}"),
 228 |     (b"Kopf", "\u{1D542}"),
 229 |     (b"Kscr", "\u{1D4A6}"),
 230 |     (b"LJcy", "\u{0409}"),
 231 |     (b"LT", "\u{003C}"),
 232 |     (b"Lacute", "\u{0139}"),
 233 |     (b"Lambda", "\u{039B}"),
 234 |     (b"Lang", "\u{27EA}"),
 235 |     (b"Laplacetrf", "\u{2112}"),
 236 |     (b"Larr", "\u{219E}"),
 237 |     (b"Lcaron", "\u{013D}"),
 238 |     (b"Lcedil", "\u{013B}"),
 239 |     (b"Lcy", "\u{041B}"),
 240 |     (b"LeftAngleBracket", "\u{27E8}"),
 241 |     (b"LeftArrow", "\u{2190}"),
 242 |     (b"LeftArrowBar", "\u{21E4}"),
 243 |     (b"LeftArrowRightArrow", "\u{21C6}"),
 244 |     (b"LeftCeiling", "\u{2308}"),
 245 |     (b"LeftDoubleBracket", "\u{27E6}"),
 246 |     (b"LeftDownTeeVector", "\u{2961}"),
 247 |     (b"LeftDownVector", "\u{21C3}"),
 248 |     (b"LeftDownVectorBar", "\u{2959}"),
 249 |     (b"LeftFloor", "\u{230A}"),
 250 |     (b"LeftRightArrow", "\u{2194}"),
 251 |     (b"LeftRightVector", "\u{294E}"),
 252 |     (b"LeftTee", "\u{22A3}"),
 253 |     (b"LeftTeeArrow", "\u{21A4}"),
 254 |     (b"LeftTeeVector", "\u{295A}"),
 255 |     (b"LeftTriangle", "\u{22B2}"),
 256 |     (b"LeftTriangleBar", "\u{29CF}"),
 257 |     (b"LeftTriangleEqual", "\u{22B4}"),
 258 |     (b"LeftUpDownVector", "\u{2951}"),
 259 |     (b"LeftUpTeeVector", "\u{2960}"),
 260 |     (b"LeftUpVector", "\u{21BF}"),
 261 |     (b"LeftUpVectorBar", "\u{2958}"),
 262 |     (b"LeftVector", "\u{21BC}"),
 263 |     (b"LeftVectorBar", "\u{2952}"),
 264 |     (b"Leftarrow", "\u{21D0}"),
 265 |     (b"Leftrightarrow", "\u{21D4}"),
 266 |     (b"LessEqualGreater", "\u{22DA}"),
 267 |     (b"LessFullEqual", "\u{2266}"),
 268 |     (b"LessGreater", "\u{2276}"),
 269 |     (b"LessLess", "\u{2AA1}"),
 270 |     (b"LessSlantEqual", "\u{2A7D}"),
 271 |     (b"LessTilde", "\u{2272}"),
 272 |     (b"Lfr", "\u{1D50F}"),
 273 |     (b"Ll", "\u{22D8}"),
 274 |     (b"Lleftarrow", "\u{21DA}"),
 275 |     (b"Lmidot", "\u{013F}"),
 276 |     (b"LongLeftArrow", "\u{27F5}"),
 277 |     (b"LongLeftRightArrow", "\u{27F7}"),
 278 |     (b"LongRightArrow", "\u{27F6}"),
 279 |     (b"Longleftarrow", "\u{27F8}"),
 280 |     (b"Longleftrightarrow", "\u{27FA}"),
 281 |     (b"Longrightarrow", "\u{27F9}"),
 282 |     (b"Lopf", "\u{1D543}"),
 283 |     (b"LowerLeftArrow", "\u{2199}"),
 284 |     (b"LowerRightArrow", "\u{2198}"),
 285 |     (b"Lscr", "\u{2112}"),
 286 |     (b"Lsh", "\u{21B0}"),
 287 |     (b"Lstrok", "\u{0141}"),
 288 |     (b"Lt", "\u{226A}"),
 289 |     (b"Map", "\u{2905}"),
 290 |     (b"Mcy", "\u{041C}"),
 291 |     (b"MediumSpace", "\u{205F}"),
 292 |     (b"Mellintrf", "\u{2133}"),
 293 |     (b"Mfr", "\u{1D510}"),
 294 |     (b"MinusPlus", "\u{2213}"),
 295 |     (b"Mopf", "\u{1D544}"),
 296 |     (b"Mscr", "\u{2133}"),
 297 |     (b"Mu", "\u{039C}"),
 298 |     (b"NJcy", "\u{040A}"),
 299 |     (b"Nacute", "\u{0143}"),
 300 |     (b"Ncaron", "\u{0147}"),
 301 |     (b"Ncedil", "\u{0145}"),
 302 |     (b"Ncy", "\u{041D}"),
 303 |     (b"NegativeMediumSpace", "\u{200B}"),
 304 |     (b"NegativeThickSpace", "\u{200B}"),
 305 |     (b"NegativeThinSpace", "\u{200B}"),
 306 |     (b"NegativeVeryThinSpace", "\u{200B}"),
 307 |     (b"NestedGreaterGreater", "\u{226B}"),
 308 |     (b"NestedLessLess", "\u{226A}"),
 309 |     (b"NewLine", "\u{000A}"),
 310 |     (b"Nfr", "\u{1D511}"),
 311 |     (b"NoBreak", "\u{2060}"),
 312 |     (b"NonBreakingSpace", "\u{00A0}"),
 313 |     (b"Nopf", "\u{2115}"),
 314 |     (b"Not", "\u{2AEC}"),
 315 |     (b"NotCongruent", "\u{2262}"),
 316 |     (b"NotCupCap", "\u{226D}"),
 317 |     (b"NotDoubleVerticalBar", "\u{2226}"),
 318 |     (b"NotElement", "\u{2209}"),
 319 |     (b"NotEqual", "\u{2260}"),
 320 |     (b"NotEqualTilde", "\u{2242}"),
 321 |     (b"NotExists", "\u{2204}"),
 322 |     (b"NotGreater", "\u{226F}"),
 323 |     (b"NotGreaterEqual", "\u{2271}"),
 324 |     (b"NotGreaterFullEqual", "\u{2267}"),
 325 |     (b"NotGreaterGreater", "\u{226B}"),
 326 |     (b"NotGreaterLess", "\u{2279}"),
 327 |     (b"NotGreaterSlantEqual", "\u{2A7E}"),
 328 |     (b"NotGreaterTilde", "\u{2275}"),
 329 |     (b"NotHumpDownHump", "\u{224E}"),
 330 |     (b"NotHumpEqual", "\u{224F}"),
 331 |     (b"NotLeftTriangle", "\u{22EA}"),
 332 |     (b"NotLeftTriangleBar", "\u{29CF}"),
 333 |     (b"NotLeftTriangleEqual", "\u{22EC}"),
 334 |     (b"NotLess", "\u{226E}"),
 335 |     (b"NotLessEqual", "\u{2270}"),
 336 |     (b"NotLessGreater", "\u{2278}"),
 337 |     (b"NotLessLess", "\u{226A}"),
 338 |     (b"NotLessSlantEqual", "\u{2A7D}"),
 339 |     (b"NotLessTilde", "\u{2274}"),
 340 |     (b"NotNestedGreaterGreater", "\u{2AA2}"),
 341 |     (b"NotNestedLessLess", "\u{2AA1}"),
 342 |     (b"NotPrecedes", "\u{2280}"),
 343 |     (b"NotPrecedesEqual", "\u{2AAF}"),
 344 |     (b"NotPrecedesSlantEqual", "\u{22E0}"),
 345 |     (b"NotReverseElement", "\u{220C}"),
 346 |     (b"NotRightTriangle", "\u{22EB}"),
 347 |     (b"NotRightTriangleBar", "\u{29D0}"),
 348 |     (b"NotRightTriangleEqual", "\u{22ED}"),
 349 |     (b"NotSquareSubset", "\u{228F}"),
 350 |     (b"NotSquareSubsetEqual", "\u{22E2}"),
 351 |     (b"NotSquareSuperset", "\u{2290}"),
 352 |     (b"NotSquareSupersetEqual", "\u{22E3}"),
 353 |     (b"NotSubset", "\u{2282}"),
 354 |     (b"NotSubsetEqual", "\u{2288}"),
 355 |     (b"NotSucceeds", "\u{2281}"),
 356 |     (b"NotSucceedsEqual", "\u{2AB0}"),
 357 |     (b"NotSucceedsSlantEqual", "\u{22E1}"),
 358 |     (b"NotSucceedsTilde", "\u{227F}"),
 359 |     (b"NotSuperset", "\u{2283}"),
 360 |     (b"NotSupersetEqual", "\u{2289}"),
 361 |     (b"NotTilde", "\u{2241}"),
 362 |     (b"NotTildeEqual", "\u{2244}"),
 363 |     (b"NotTildeFullEqual", "\u{2247}"),
 364 |     (b"NotTildeTilde", "\u{2249}"),
 365 |     (b"NotVerticalBar", "\u{2224}"),
 366 |     (b"Nscr", "\u{1D4A9}"),
 367 |     (b"Ntilde", "\u{00D1}"),
 368 |     (b"Nu", "\u{039D}"),
 369 |     (b"OElig", "\u{0152}"),
 370 |     (b"Oacute", "\u{00D3}"),
 371 |     (b"Ocirc", "\u{00D4}"),
 372 |     (b"Ocy", "\u{041E}"),
 373 |     (b"Odblac", "\u{0150}"),
 374 |     (b"Ofr", "\u{1D512}"),
 375 |     (b"Ograve", "\u{00D2}"),
 376 |     (b"Omacr", "\u{014C}"),
 377 |     (b"Omega", "\u{03A9}"),
 378 |     (b"Omicron", "\u{039F}"),
 379 |     (b"Oopf", "\u{1D546}"),
 380 |     (b"OpenCurlyDoubleQuote", "\u{201C}"),
 381 |     (b"OpenCurlyQuote", "\u{2018}"),
 382 |     (b"Or", "\u{2A54}"),
 383 |     (b"Oscr", "\u{1D4AA}"),
 384 |     (b"Oslash", "\u{00D8}"),
 385 |     (b"Otilde", "\u{00D5}"),
 386 |     (b"Otimes", "\u{2A37}"),
 387 |     (b"Ouml", "\u{00D6}"),
 388 |     (b"OverBar", "\u{203E}"),
 389 |     (b"OverBrace", "\u{23DE}"),
 390 |     (b"OverBracket", "\u{23B4}"),
 391 |     (b"OverParenthesis", "\u{23DC}"),
 392 |     (b"PartialD", "\u{2202}"),
 393 |     (b"Pcy", "\u{041F}"),
 394 |     (b"Pfr", "\u{1D513}"),
 395 |     (b"Phi", "\u{03A6}"),
 396 |     (b"Pi", "\u{03A0}"),
 397 |     (b"PlusMinus", "\u{00B1}"),
 398 |     (b"Poincareplane", "\u{210C}"),
 399 |     (b"Popf", "\u{2119}"),
 400 |     (b"Pr", "\u{2ABB}"),
 401 |     (b"Precedes", "\u{227A}"),
 402 |     (b"PrecedesEqual", "\u{2AAF}"),
 403 |     (b"PrecedesSlantEqual", "\u{227C}"),
 404 |     (b"PrecedesTilde", "\u{227E}"),
 405 |     (b"Prime", "\u{2033}"),
 406 |     (b"Product", "\u{220F}"),
 407 |     (b"Proportion", "\u{2237}"),
 408 |     (b"Proportional", "\u{221D}"),
 409 |     (b"Pscr", "\u{1D4AB}"),
 410 |     (b"Psi", "\u{03A8}"),
 411 |     (b"QUOT", "\u{0022}"),
 412 |     (b"Qfr", "\u{1D514}"),
 413 |     (b"Qopf", "\u{211A}"),
 414 |     (b"Qscr", "\u{1D4AC}"),
 415 |     (b"RBarr", "\u{2910}"),
 416 |     (b"REG", "\u{00AE}"),
 417 |     (b"Racute", "\u{0154}"),
 418 |     (b"Rang", "\u{27EB}"),
 419 |     (b"Rarr", "\u{21A0}"),
 420 |     (b"Rarrtl", "\u{2916}"),
 421 |     (b"Rcaron", "\u{0158}"),
 422 |     (b"Rcedil", "\u{0156}"),
 423 |     (b"Rcy", "\u{0420}"),
 424 |     (b"Re", "\u{211C}"),
 425 |     (b"ReverseElement", "\u{220B}"),
 426 |     (b"ReverseEquilibrium", "\u{21CB}"),
 427 |     (b"ReverseUpEquilibrium", "\u{296F}"),
 428 |     (b"Rfr", "\u{211C}"),
 429 |     (b"Rho", "\u{03A1}"),
 430 |     (b"RightAngleBracket", "\u{27E9}"),
 431 |     (b"RightArrow", "\u{2192}"),
 432 |     (b"RightArrowBar", "\u{21E5}"),
 433 |     (b"RightArrowLeftArrow", "\u{21C4}"),
 434 |     (b"RightCeiling", "\u{2309}"),
 435 |     (b"RightDoubleBracket", "\u{27E7}"),
 436 |     (b"RightDownTeeVector", "\u{295D}"),
 437 |     (b"RightDownVector", "\u{21C2}"),
 438 |     (b"RightDownVectorBar", "\u{2955}"),
 439 |     (b"RightFloor", "\u{230B}"),
 440 |     (b"RightTee", "\u{22A2}"),
 441 |     (b"RightTeeArrow", "\u{21A6}"),
 442 |     (b"RightTeeVector", "\u{295B}"),
 443 |     (b"RightTriangle", "\u{22B3}"),
 444 |     (b"RightTriangleBar", "\u{29D0}"),
 445 |     (b"RightTriangleEqual", "\u{22B5}"),
 446 |     (b"RightUpDownVector", "\u{294F}"),
 447 |     (b"RightUpTeeVector", "\u{295C}"),
 448 |     (b"RightUpVector", "\u{21BE}"),
 449 |     (b"RightUpVectorBar", "\u{2954}"),
 450 |     (b"RightVector", "\u{21C0}"),
 451 |     (b"RightVectorBar", "\u{2953}"),
 452 |     (b"Rightarrow", "\u{21D2}"),
 453 |     (b"Ropf", "\u{211D}"),
 454 |     (b"RoundImplies", "\u{2970}"),
 455 |     (b"Rrightarrow", "\u{21DB}"),
 456 |     (b"Rscr", "\u{211B}"),
 457 |     (b"Rsh", "\u{21B1}"),
 458 |     (b"RuleDelayed", "\u{29F4}"),
 459 |     (b"SHCHcy", "\u{0429}"),
 460 |     (b"SHcy", "\u{0428}"),
 461 |     (b"SOFTcy", "\u{042C}"),
 462 |     (b"Sacute", "\u{015A}"),
 463 |     (b"Sc", "\u{2ABC}"),
 464 |     (b"Scaron", "\u{0160}"),
 465 |     (b"Scedil", "\u{015E}"),
 466 |     (b"Scirc", "\u{015C}"),
 467 |     (b"Scy", "\u{0421}"),
 468 |     (b"Sfr", "\u{1D516}"),
 469 |     (b"ShortDownArrow", "\u{2193}"),
 470 |     (b"ShortLeftArrow", "\u{2190}"),
 471 |     (b"ShortRightArrow", "\u{2192}"),
 472 |     (b"ShortUpArrow", "\u{2191}"),
 473 |     (b"Sigma", "\u{03A3}"),
 474 |     (b"SmallCircle", "\u{2218}"),
 475 |     (b"Sopf", "\u{1D54A}"),
 476 |     (b"Sqrt", "\u{221A}"),
 477 |     (b"Square", "\u{25A1}"),
 478 |     (b"SquareIntersection", "\u{2293}"),
 479 |     (b"SquareSubset", "\u{228F}"),
 480 |     (b"SquareSubsetEqual", "\u{2291}"),
 481 |     (b"SquareSuperset", "\u{2290}"),
 482 |     (b"SquareSupersetEqual", "\u{2292}"),
 483 |     (b"SquareUnion", "\u{2294}"),
 484 |     (b"Sscr", "\u{1D4AE}"),
 485 |     (b"Star", "\u{22C6}"),
 486 |     (b"Sub", "\u{22D0}"),
 487 |     (b"Subset", "\u{22D0}"),
 488 |     (b"SubsetEqual", "\u{2286}"),
 489 |     (b"Succeeds", "\u{227B}"),
 490 |     (b"SucceedsEqual", "\u{2AB0}"),
 491 |     (b"SucceedsSlantEqual", "\u{227D}"),
 492 |     (b"SucceedsTilde", "\u{227F}"),
 493 |     (b"SuchThat", "\u{220B}"),
 494 |     (b"Sum", "\u{2211}"),
 495 |     (b"Sup", "\u{22D1}"),
 496 |     (b"Superset", "\u{2283}"),
 497 |     (b"SupersetEqual", "\u{2287}"),
 498 |     (b"Supset", "\u{22D1}"),
 499 |     (b"THORN", "\u{00DE}"),
 500 |     (b"TRADE", "\u{2122}"),
 501 |     (b"TSHcy", "\u{040B}"),
 502 |     (b"TScy", "\u{0426}"),
 503 |     (b"Tab", "\u{0009}"),
 504 |     (b"Tau", "\u{03A4}"),
 505 |     (b"Tcaron", "\u{0164}"),
 506 |     (b"Tcedil", "\u{0162}"),
 507 |     (b"Tcy", "\u{0422}"),
 508 |     (b"Tfr", "\u{1D517}"),
 509 |     (b"Therefore", "\u{2234}"),
 510 |     (b"Theta", "\u{0398}"),
 511 |     (b"ThickSpace", "\u{205F}"),
 512 |     (b"ThinSpace", "\u{2009}"),
 513 |     (b"Tilde", "\u{223C}"),
 514 |     (b"TildeEqual", "\u{2243}"),
 515 |     (b"TildeFullEqual", "\u{2245}"),
 516 |     (b"TildeTilde", "\u{2248}"),
 517 |     (b"Topf", "\u{1D54B}"),
 518 |     (b"TripleDot", "\u{20DB}"),
 519 |     (b"Tscr", "\u{1D4AF}"),
 520 |     (b"Tstrok", "\u{0166}"),
 521 |     (b"Uacute", "\u{00DA}"),
 522 |     (b"Uarr", "\u{219F}"),
 523 |     (b"Uarrocir", "\u{2949}"),
 524 |     (b"Ubrcy", "\u{040E}"),
 525 |     (b"Ubreve", "\u{016C}"),
 526 |     (b"Ucirc", "\u{00DB}"),
 527 |     (b"Ucy", "\u{0423}"),
 528 |     (b"Udblac", "\u{0170}"),
 529 |     (b"Ufr", "\u{1D518}"),
 530 |     (b"Ugrave", "\u{00D9}"),
 531 |     (b"Umacr", "\u{016A}"),
 532 |     (b"UnderBar", "\u{005F}"),
 533 |     (b"UnderBrace", "\u{23DF}"),
 534 |     (b"UnderBracket", "\u{23B5}"),
 535 |     (b"UnderParenthesis", "\u{23DD}"),
 536 |     (b"Union", "\u{22C3}"),
 537 |     (b"UnionPlus", "\u{228E}"),
 538 |     (b"Uogon", "\u{0172}"),
 539 |     (b"Uopf", "\u{1D54C}"),
 540 |     (b"UpArrow", "\u{2191}"),
 541 |     (b"UpArrowBar", "\u{2912}"),
 542 |     (b"UpArrowDownArrow", "\u{21C5}"),
 543 |     (b"UpDownArrow", "\u{2195}"),
 544 |     (b"UpEquilibrium", "\u{296E}"),
 545 |     (b"UpTee", "\u{22A5}"),
 546 |     (b"UpTeeArrow", "\u{21A5}"),
 547 |     (b"Uparrow", "\u{21D1}"),
 548 |     (b"Updownarrow", "\u{21D5}"),
 549 |     (b"UpperLeftArrow", "\u{2196}"),
 550 |     (b"UpperRightArrow", "\u{2197}"),
 551 |     (b"Upsi", "\u{03D2}"),
 552 |     (b"Upsilon", "\u{03A5}"),
 553 |     (b"Uring", "\u{016E}"),
 554 |     (b"Uscr", "\u{1D4B0}"),
 555 |     (b"Utilde", "\u{0168}"),
 556 |     (b"Uuml", "\u{00DC}"),
 557 |     (b"VDash", "\u{22AB}"),
 558 |     (b"Vbar", "\u{2AEB}"),
 559 |     (b"Vcy", "\u{0412}"),
 560 |     (b"Vdash", "\u{22A9}"),
 561 |     (b"Vdashl", "\u{2AE6}"),
 562 |     (b"Vee", "\u{22C1}"),
 563 |     (b"Verbar", "\u{2016}"),
 564 |     (b"Vert", "\u{2016}"),
 565 |     (b"VerticalBar", "\u{2223}"),
 566 |     (b"VerticalLine", "\u{007C}"),
 567 |     (b"VerticalSeparator", "\u{2758}"),
 568 |     (b"VerticalTilde", "\u{2240}"),
 569 |     (b"VeryThinSpace", "\u{200A}"),
 570 |     (b"Vfr", "\u{1D519}"),
 571 |     (b"Vopf", "\u{1D54D}"),
 572 |     (b"Vscr", "\u{1D4B1}"),
 573 |     (b"Vvdash", "\u{22AA}"),
 574 |     (b"Wcirc", "\u{0174}"),
 575 |     (b"Wedge", "\u{22C0}"),
 576 |     (b"Wfr", "\u{1D51A}"),
 577 |     (b"Wopf", "\u{1D54E}"),
 578 |     (b"Wscr", "\u{1D4B2}"),
 579 |     (b"Xfr", "\u{1D51B}"),
 580 |     (b"Xi", "\u{039E}"),
 581 |     (b"Xopf", "\u{1D54F}"),
 582 |     (b"Xscr", "\u{1D4B3}"),
 583 |     (b"YAcy", "\u{042F}"),
 584 |     (b"YIcy", "\u{0407}"),
 585 |     (b"YUcy", "\u{042E}"),
 586 |     (b"Yacute", "\u{00DD}"),
 587 |     (b"Ycirc", "\u{0176}"),
 588 |     (b"Ycy", "\u{042B}"),
 589 |     (b"Yfr", "\u{1D51C}"),
 590 |     (b"Yopf", "\u{1D550}"),
 591 |     (b"Yscr", "\u{1D4B4}"),
 592 |     (b"Yuml", "\u{0178}"),
 593 |     (b"ZHcy", "\u{0416}"),
 594 |     (b"Zacute", "\u{0179}"),
 595 |     (b"Zcaron", "\u{017D}"),
 596 |     (b"Zcy", "\u{0417}"),
 597 |     (b"Zdot", "\u{017B}"),
 598 |     (b"ZeroWidthSpace", "\u{200B}"),
 599 |     (b"Zeta", "\u{0396}"),
 600 |     (b"Zfr", "\u{2128}"),
 601 |     (b"Zopf", "\u{2124}"),
 602 |     (b"Zscr", "\u{1D4B5}"),
 603 |     (b"aacute", "\u{00E1}"),
 604 |     (b"abreve", "\u{0103}"),
 605 |     (b"ac", "\u{223E}"),
 606 |     (b"acE", "\u{223E}"),
 607 |     (b"acd", "\u{223F}"),
 608 |     (b"acirc", "\u{00E2}"),
 609 |     (b"acute", "\u{00B4}"),
 610 |     (b"acy", "\u{0430}"),
 611 |     (b"aelig", "\u{00E6}"),
 612 |     (b"af", "\u{2061}"),
 613 |     (b"afr", "\u{1D51E}"),
 614 |     (b"agrave", "\u{00E0}"),
 615 |     (b"alefsym", "\u{2135}"),
 616 |     (b"aleph", "\u{2135}"),
 617 |     (b"alpha", "\u{03B1}"),
 618 |     (b"amacr", "\u{0101}"),
 619 |     (b"amalg", "\u{2A3F}"),
 620 |     (b"amp", "\u{0026}"),
 621 |     (b"and", "\u{2227}"),
 622 |     (b"andand", "\u{2A55}"),
 623 |     (b"andd", "\u{2A5C}"),
 624 |     (b"andslope", "\u{2A58}"),
 625 |     (b"andv", "\u{2A5A}"),
 626 |     (b"ang", "\u{2220}"),
 627 |     (b"ange", "\u{29A4}"),
 628 |     (b"angle", "\u{2220}"),
 629 |     (b"angmsd", "\u{2221}"),
 630 |     (b"angmsdaa", "\u{29A8}"),
 631 |     (b"angmsdab", "\u{29A9}"),
 632 |     (b"angmsdac", "\u{29AA}"),
 633 |     (b"angmsdad", "\u{29AB}"),
 634 |     (b"angmsdae", "\u{29AC}"),
 635 |     (b"angmsdaf", "\u{29AD}"),
 636 |     (b"angmsdag", "\u{29AE}"),
 637 |     (b"angmsdah", "\u{29AF}"),
 638 |     (b"angrt", "\u{221F}"),
 639 |     (b"angrtvb", "\u{22BE}"),
 640 |     (b"angrtvbd", "\u{299D}"),
 641 |     (b"angsph", "\u{2222}"),
 642 |     (b"angst", "\u{00C5}"),
 643 |     (b"angzarr", "\u{237C}"),
 644 |     (b"aogon", "\u{0105}"),
 645 |     (b"aopf", "\u{1D552}"),
 646 |     (b"ap", "\u{2248}"),
 647 |     (b"apE", "\u{2A70}"),
 648 |     (b"apacir", "\u{2A6F}"),
 649 |     (b"ape", "\u{224A}"),
 650 |     (b"apid", "\u{224B}"),
 651 |     (b"apos", "\u{0027}"),
 652 |     (b"approx", "\u{2248}"),
 653 |     (b"approxeq", "\u{224A}"),
 654 |     (b"aring", "\u{00E5}"),
 655 |     (b"ascr", "\u{1D4B6}"),
 656 |     (b"ast", "\u{002A}"),
 657 |     (b"asymp", "\u{2248}"),
 658 |     (b"asympeq", "\u{224D}"),
 659 |     (b"atilde", "\u{00E3}"),
 660 |     (b"auml", "\u{00E4}"),
 661 |     (b"awconint", "\u{2233}"),
 662 |     (b"awint", "\u{2A11}"),
 663 |     (b"bNot", "\u{2AED}"),
 664 |     (b"backcong", "\u{224C}"),
 665 |     (b"backepsilon", "\u{03F6}"),
 666 |     (b"backprime", "\u{2035}"),
 667 |     (b"backsim", "\u{223D}"),
 668 |     (b"backsimeq", "\u{22CD}"),
 669 |     (b"barvee", "\u{22BD}"),
 670 |     (b"barwed", "\u{2305}"),
 671 |     (b"barwedge", "\u{2305}"),
 672 |     (b"bbrk", "\u{23B5}"),
 673 |     (b"bbrktbrk", "\u{23B6}"),
 674 |     (b"bcong", "\u{224C}"),
 675 |     (b"bcy", "\u{0431}"),
 676 |     (b"bdquo", "\u{201E}"),
 677 |     (b"becaus", "\u{2235}"),
 678 |     (b"because", "\u{2235}"),
 679 |     (b"bemptyv", "\u{29B0}"),
 680 |     (b"bepsi", "\u{03F6}"),
 681 |     (b"bernou", "\u{212C}"),
 682 |     (b"beta", "\u{03B2}"),
 683 |     (b"beth", "\u{2136}"),
 684 |     (b"between", "\u{226C}"),
 685 |     (b"bfr", "\u{1D51F}"),
 686 |     (b"bigcap", "\u{22C2}"),
 687 |     (b"bigcirc", "\u{25EF}"),
 688 |     (b"bigcup", "\u{22C3}"),
 689 |     (b"bigodot", "\u{2A00}"),
 690 |     (b"bigoplus", "\u{2A01}"),
 691 |     (b"bigotimes", "\u{2A02}"),
 692 |     (b"bigsqcup", "\u{2A06}"),
 693 |     (b"bigstar", "\u{2605}"),
 694 |     (b"bigtriangledown", "\u{25BD}"),
 695 |     (b"bigtriangleup", "\u{25B3}"),
 696 |     (b"biguplus", "\u{2A04}"),
 697 |     (b"bigvee", "\u{22C1}"),
 698 |     (b"bigwedge", "\u{22C0}"),
 699 |     (b"bkarow", "\u{290D}"),
 700 |     (b"blacklozenge", "\u{29EB}"),
 701 |     (b"blacksquare", "\u{25AA}"),
 702 |     (b"blacktriangle", "\u{25B4}"),
 703 |     (b"blacktriangledown", "\u{25BE}"),
 704 |     (b"blacktriangleleft", "\u{25C2}"),
 705 |     (b"blacktriangleright", "\u{25B8}"),
 706 |     (b"blank", "\u{2423}"),
 707 |     (b"blk12", "\u{2592}"),
 708 |     (b"blk14", "\u{2591}"),
 709 |     (b"blk34", "\u{2593}"),
 710 |     (b"block", "\u{2588}"),
 711 |     (b"bne", "\u{003D}"),
 712 |     (b"bnequiv", "\u{2261}"),
 713 |     (b"bnot", "\u{2310}"),
 714 |     (b"bopf", "\u{1D553}"),
 715 |     (b"bot", "\u{22A5}"),
 716 |     (b"bottom", "\u{22A5}"),
 717 |     (b"bowtie", "\u{22C8}"),
 718 |     (b"boxDL", "\u{2557}"),
 719 |     (b"boxDR", "\u{2554}"),
 720 |     (b"boxDl", "\u{2556}"),
 721 |     (b"boxDr", "\u{2553}"),
 722 |     (b"boxH", "\u{2550}"),
 723 |     (b"boxHD", "\u{2566}"),
 724 |     (b"boxHU", "\u{2569}"),
 725 |     (b"boxHd", "\u{2564}"),
 726 |     (b"boxHu", "\u{2567}"),
 727 |     (b"boxUL", "\u{255D}"),
 728 |     (b"boxUR", "\u{255A}"),
 729 |     (b"boxUl", "\u{255C}"),
 730 |     (b"boxUr", "\u{2559}"),
 731 |     (b"boxV", "\u{2551}"),
 732 |     (b"boxVH", "\u{256C}"),
 733 |     (b"boxVL", "\u{2563}"),
 734 |     (b"boxVR", "\u{2560}"),
 735 |     (b"boxVh", "\u{256B}"),
 736 |     (b"boxVl", "\u{2562}"),
 737 |     (b"boxVr", "\u{255F}"),
 738 |     (b"boxbox", "\u{29C9}"),
 739 |     (b"boxdL", "\u{2555}"),
 740 |     (b"boxdR", "\u{2552}"),
 741 |     (b"boxdl", "\u{2510}"),
 742 |     (b"boxdr", "\u{250C}"),
 743 |     (b"boxh", "\u{2500}"),
 744 |     (b"boxhD", "\u{2565}"),
 745 |     (b"boxhU", "\u{2568}"),
 746 |     (b"boxhd", "\u{252C}"),
 747 |     (b"boxhu", "\u{2534}"),
 748 |     (b"boxminus", "\u{229F}"),
 749 |     (b"boxplus", "\u{229E}"),
 750 |     (b"boxtimes", "\u{22A0}"),
 751 |     (b"boxuL", "\u{255B}"),
 752 |     (b"boxuR", "\u{2558}"),
 753 |     (b"boxul", "\u{2518}"),
 754 |     (b"boxur", "\u{2514}"),
 755 |     (b"boxv", "\u{2502}"),
 756 |     (b"boxvH", "\u{256A}"),
 757 |     (b"boxvL", "\u{2561}"),
 758 |     (b"boxvR", "\u{255E}"),
 759 |     (b"boxvh", "\u{253C}"),
 760 |     (b"boxvl", "\u{2524}"),
 761 |     (b"boxvr", "\u{251C}"),
 762 |     (b"bprime", "\u{2035}"),
 763 |     (b"breve", "\u{02D8}"),
 764 |     (b"brvbar", "\u{00A6}"),
 765 |     (b"bscr", "\u{1D4B7}"),
 766 |     (b"bsemi", "\u{204F}"),
 767 |     (b"bsim", "\u{223D}"),
 768 |     (b"bsime", "\u{22CD}"),
 769 |     (b"bsol", "\u{005C}"),
 770 |     (b"bsolb", "\u{29C5}"),
 771 |     (b"bsolhsub", "\u{27C8}"),
 772 |     (b"bull", "\u{2022}"),
 773 |     (b"bullet", "\u{2022}"),
 774 |     (b"bump", "\u{224E}"),
 775 |     (b"bumpE", "\u{2AAE}"),
 776 |     (b"bumpe", "\u{224F}"),
 777 |     (b"bumpeq", "\u{224F}"),
 778 |     (b"cacute", "\u{0107}"),
 779 |     (b"cap", "\u{2229}"),
 780 |     (b"capand", "\u{2A44}"),
 781 |     (b"capbrcup", "\u{2A49}"),
 782 |     (b"capcap", "\u{2A4B}"),
 783 |     (b"capcup", "\u{2A47}"),
 784 |     (b"capdot", "\u{2A40}"),
 785 |     (b"caps", "\u{2229}"),
 786 |     (b"caret", "\u{2041}"),
 787 |     (b"caron", "\u{02C7}"),
 788 |     (b"ccaps", "\u{2A4D}"),
 789 |     (b"ccaron", "\u{010D}"),
 790 |     (b"ccedil", "\u{00E7}"),
 791 |     (b"ccirc", "\u{0109}"),
 792 |     (b"ccups", "\u{2A4C}"),
 793 |     (b"ccupssm", "\u{2A50}"),
 794 |     (b"cdot", "\u{010B}"),
 795 |     (b"cedil", "\u{00B8}"),
 796 |     (b"cemptyv", "\u{29B2}"),
 797 |     (b"cent", "\u{00A2}"),
 798 |     (b"centerdot", "\u{00B7}"),
 799 |     (b"cfr", "\u{1D520}"),
 800 |     (b"chcy", "\u{0447}"),
 801 |     (b"check", "\u{2713}"),
 802 |     (b"checkmark", "\u{2713}"),
 803 |     (b"chi", "\u{03C7}"),
 804 |     (b"cir", "\u{25CB}"),
 805 |     (b"cirE", "\u{29C3}"),
 806 |     (b"circ", "\u{02C6}"),
 807 |     (b"circeq", "\u{2257}"),
 808 |     (b"circlearrowleft", "\u{21BA}"),
 809 |     (b"circlearrowright", "\u{21BB}"),
 810 |     (b"circledR", "\u{00AE}"),
 811 |     (b"circledS", "\u{24C8}"),
 812 |     (b"circledast", "\u{229B}"),
 813 |     (b"circledcirc", "\u{229A}"),
 814 |     (b"circleddash", "\u{229D}"),
 815 |     (b"cire", "\u{2257}"),
 816 |     (b"cirfnint", "\u{2A10}"),
 817 |     (b"cirmid", "\u{2AEF}"),
 818 |     (b"cirscir", "\u{29C2}"),
 819 |     (b"clubs", "\u{2663}"),
 820 |     (b"clubsuit", "\u{2663}"),
 821 |     (b"colon", "\u{003A}"),
 822 |     (b"colone", "\u{2254}"),
 823 |     (b"coloneq", "\u{2254}"),
 824 |     (b"comma", "\u{002C}"),
 825 |     (b"commat", "\u{0040}"),
 826 |     (b"comp", "\u{2201}"),
 827 |     (b"compfn", "\u{2218}"),
 828 |     (b"complement", "\u{2201}"),
 829 |     (b"complexes", "\u{2102}"),
 830 |     (b"cong", "\u{2245}"),
 831 |     (b"congdot", "\u{2A6D}"),
 832 |     (b"conint", "\u{222E}"),
 833 |     (b"copf", "\u{1D554}"),
 834 |     (b"coprod", "\u{2210}"),
 835 |     (b"copy", "\u{00A9}"),
 836 |     (b"copysr", "\u{2117}"),
 837 |     (b"crarr", "\u{21B5}"),
 838 |     (b"cross", "\u{2717}"),
 839 |     (b"cscr", "\u{1D4B8}"),
 840 |     (b"csub", "\u{2ACF}"),
 841 |     (b"csube", "\u{2AD1}"),
 842 |     (b"csup", "\u{2AD0}"),
 843 |     (b"csupe", "\u{2AD2}"),
 844 |     (b"ctdot", "\u{22EF}"),
 845 |     (b"cudarrl", "\u{2938}"),
 846 |     (b"cudarrr", "\u{2935}"),
 847 |     (b"cuepr", "\u{22DE}"),
 848 |     (b"cuesc", "\u{22DF}"),
 849 |     (b"cularr", "\u{21B6}"),
 850 |     (b"cularrp", "\u{293D}"),
 851 |     (b"cup", "\u{222A}"),
 852 |     (b"cupbrcap", "\u{2A48}"),
 853 |     (b"cupcap", "\u{2A46}"),
 854 |     (b"cupcup", "\u{2A4A}"),
 855 |     (b"cupdot", "\u{228D}"),
 856 |     (b"cupor", "\u{2A45}"),
 857 |     (b"cups", "\u{222A}"),
 858 |     (b"curarr", "\u{21B7}"),
 859 |     (b"curarrm", "\u{293C}"),
 860 |     (b"curlyeqprec", "\u{22DE}"),
 861 |     (b"curlyeqsucc", "\u{22DF}"),
 862 |     (b"curlyvee", "\u{22CE}"),
 863 |     (b"curlywedge", "\u{22CF}"),
 864 |     (b"curren", "\u{00A4}"),
 865 |     (b"curvearrowleft", "\u{21B6}"),
 866 |     (b"curvearrowright", "\u{21B7}"),
 867 |     (b"cuvee", "\u{22CE}"),
 868 |     (b"cuwed", "\u{22CF}"),
 869 |     (b"cwconint", "\u{2232}"),
 870 |     (b"cwint", "\u{2231}"),
 871 |     (b"cylcty", "\u{232D}"),
 872 |     (b"dArr", "\u{21D3}"),
 873 |     (b"dHar", "\u{2965}"),
 874 |     (b"dagger", "\u{2020}"),
 875 |     (b"daleth", "\u{2138}"),
 876 |     (b"darr", "\u{2193}"),
 877 |     (b"dash", "\u{2010}"),
 878 |     (b"dashv", "\u{22A3}"),
 879 |     (b"dbkarow", "\u{290F}"),
 880 |     (b"dblac", "\u{02DD}"),
 881 |     (b"dcaron", "\u{010F}"),
 882 |     (b"dcy", "\u{0434}"),
 883 |     (b"dd", "\u{2146}"),
 884 |     (b"ddagger", "\u{2021}"),
 885 |     (b"ddarr", "\u{21CA}"),
 886 |     (b"ddotseq", "\u{2A77}"),
 887 |     (b"deg", "\u{00B0}"),
 888 |     (b"delta", "\u{03B4}"),
 889 |     (b"demptyv", "\u{29B1}"),
 890 |     (b"dfisht", "\u{297F}"),
 891 |     (b"dfr", "\u{1D521}"),
 892 |     (b"dharl", "\u{21C3}"),
 893 |     (b"dharr", "\u{21C2}"),
 894 |     (b"diam", "\u{22C4}"),
 895 |     (b"diamond", "\u{22C4}"),
 896 |     (b"diamondsuit", "\u{2666}"),
 897 |     (b"diams", "\u{2666}"),
 898 |     (b"die", "\u{00A8}"),
 899 |     (b"digamma", "\u{03DD}"),
 900 |     (b"disin", "\u{22F2}"),
 901 |     (b"div", "\u{00F7}"),
 902 |     (b"divide", "\u{00F7}"),
 903 |     (b"divideontimes", "\u{22C7}"),
 904 |     (b"divonx", "\u{22C7}"),
 905 |     (b"djcy", "\u{0452}"),
 906 |     (b"dlcorn", "\u{231E}"),
 907 |     (b"dlcrop", "\u{230D}"),
 908 |     (b"dollar", "\u{0024}"),
 909 |     (b"dopf", "\u{1D555}"),
 910 |     (b"dot", "\u{02D9}"),
 911 |     (b"doteq", "\u{2250}"),
 912 |     (b"doteqdot", "\u{2251}"),
 913 |     (b"dotminus", "\u{2238}"),
 914 |     (b"dotplus", "\u{2214}"),
 915 |     (b"dotsquare", "\u{22A1}"),
 916 |     (b"doublebarwedge", "\u{2306}"),
 917 |     (b"downarrow", "\u{2193}"),
 918 |     (b"downdownarrows", "\u{21CA}"),
 919 |     (b"downharpoonleft", "\u{21C3}"),
 920 |     (b"downharpoonright", "\u{21C2}"),
 921 |     (b"drbkarow", "\u{2910}"),
 922 |     (b"drcorn", "\u{231F}"),
 923 |     (b"drcrop", "\u{230C}"),
 924 |     (b"dscr", "\u{1D4B9}"),
 925 |     (b"dscy", "\u{0455}"),
 926 |     (b"dsol", "\u{29F6}"),
 927 |     (b"dstrok", "\u{0111}"),
 928 |     (b"dtdot", "\u{22F1}"),
 929 |     (b"dtri", "\u{25BF}"),
 930 |     (b"dtrif", "\u{25BE}"),
 931 |     (b"duarr", "\u{21F5}"),
 932 |     (b"duhar", "\u{296F}"),
 933 |     (b"dwangle", "\u{29A6}"),
 934 |     (b"dzcy", "\u{045F}"),
 935 |     (b"dzigrarr", "\u{27FF}"),
 936 |     (b"eDDot", "\u{2A77}"),
 937 |     (b"eDot", "\u{2251}"),
 938 |     (b"eacute", "\u{00E9}"),
 939 |     (b"easter", "\u{2A6E}"),
 940 |     (b"ecaron", "\u{011B}"),
 941 |     (b"ecir", "\u{2256}"),
 942 |     (b"ecirc", "\u{00EA}"),
 943 |     (b"ecolon", "\u{2255}"),
 944 |     (b"ecy", "\u{044D}"),
 945 |     (b"edot", "\u{0117}"),
 946 |     (b"ee", "\u{2147}"),
 947 |     (b"efDot", "\u{2252}"),
 948 |     (b"efr", "\u{1D522}"),
 949 |     (b"eg", "\u{2A9A}"),
 950 |     (b"egrave", "\u{00E8}"),
 951 |     (b"egs", "\u{2A96}"),
 952 |     (b"egsdot", "\u{2A98}"),
 953 |     (b"el", "\u{2A99}"),
 954 |     (b"elinters", "\u{23E7}"),
 955 |     (b"ell", "\u{2113}"),
 956 |     (b"els", "\u{2A95}"),
 957 |     (b"elsdot", "\u{2A97}"),
 958 |     (b"emacr", "\u{0113}"),
 959 |     (b"empty", "\u{2205}"),
 960 |     (b"emptyset", "\u{2205}"),
 961 |     (b"emptyv", "\u{2205}"),
 962 |     (b"emsp", "\u{2003}"),
 963 |     (b"emsp13", "\u{2004}"),
 964 |     (b"emsp14", "\u{2005}"),
 965 |     (b"eng", "\u{014B}"),
 966 |     (b"ensp", "\u{2002}"),
 967 |     (b"eogon", "\u{0119}"),
 968 |     (b"eopf", "\u{1D556}"),
 969 |     (b"epar", "\u{22D5}"),
 970 |     (b"eparsl", "\u{29E3}"),
 971 |     (b"eplus", "\u{2A71}"),
 972 |     (b"epsi", "\u{03B5}"),
 973 |     (b"epsilon", "\u{03B5}"),
 974 |     (b"epsiv", "\u{03F5}"),
 975 |     (b"eqcirc", "\u{2256}"),
 976 |     (b"eqcolon", "\u{2255}"),
 977 |     (b"eqsim", "\u{2242}"),
 978 |     (b"eqslantgtr", "\u{2A96}"),
 979 |     (b"eqslantless", "\u{2A95}"),
 980 |     (b"equals", "\u{003D}"),
 981 |     (b"equest", "\u{225F}"),
 982 |     (b"equiv", "\u{2261}"),
 983 |     (b"equivDD", "\u{2A78}"),
 984 |     (b"eqvparsl", "\u{29E5}"),
 985 |     (b"erDot", "\u{2253}"),
 986 |     (b"erarr", "\u{2971}"),
 987 |     (b"escr", "\u{212F}"),
 988 |     (b"esdot", "\u{2250}"),
 989 |     (b"esim", "\u{2242}"),
 990 |     (b"eta", "\u{03B7}"),
 991 |     (b"eth", "\u{00F0}"),
 992 |     (b"euml", "\u{00EB}"),
 993 |     (b"euro", "\u{20AC}"),
 994 |     (b"excl", "\u{0021}"),
 995 |     (b"exist", "\u{2203}"),
 996 |     (b"expectation", "\u{2130}"),
 997 |     (b"exponentiale", "\u{2147}"),
 998 |     (b"fallingdotseq", "\u{2252}"),
 999 |     (b"fcy", "\u{0444}"),
1000 |     (b"female", "\u{2640}"),
1001 |     (b"ffilig", "\u{FB03}"),
1002 |     (b"fflig", "\u{FB00}"),
1003 |     (b"ffllig", "\u{FB04}"),
1004 |     (b"ffr", "\u{1D523}"),
1005 |     (b"filig", "\u{FB01}"),
1006 |     (b"fjlig", "\u{0066}"),
1007 |     (b"flat", "\u{266D}"),
1008 |     (b"fllig", "\u{FB02}"),
1009 |     (b"fltns", "\u{25B1}"),
1010 |     (b"fnof", "\u{0192}"),
1011 |     (b"fopf", "\u{1D557}"),
1012 |     (b"forall", "\u{2200}"),
1013 |     (b"fork", "\u{22D4}"),
1014 |     (b"forkv", "\u{2AD9}"),
1015 |     (b"fpartint", "\u{2A0D}"),
1016 |     (b"frac12", "\u{00BD}"),
1017 |     (b"frac13", "\u{2153}"),
1018 |     (b"frac14", "\u{00BC}"),
1019 |     (b"frac15", "\u{2155}"),
1020 |     (b"frac16", "\u{2159}"),
1021 |     (b"frac18", "\u{215B}"),
1022 |     (b"frac23", "\u{2154}"),
1023 |     (b"frac25", "\u{2156}"),
1024 |     (b"frac34", "\u{00BE}"),
1025 |     (b"frac35", "\u{2157}"),
1026 |     (b"frac38", "\u{215C}"),
1027 |     (b"frac45", "\u{2158}"),
1028 |     (b"frac56", "\u{215A}"),
1029 |     (b"frac58", "\u{215D}"),
1030 |     (b"frac78", "\u{215E}"),
1031 |     (b"frasl", "\u{2044}"),
1032 |     (b"frown", "\u{2322}"),
1033 |     (b"fscr", "\u{1D4BB}"),
1034 |     (b"gE", "\u{2267}"),
1035 |     (b"gEl", "\u{2A8C}"),
1036 |     (b"gacute", "\u{01F5}"),
1037 |     (b"gamma", "\u{03B3}"),
1038 |     (b"gammad", "\u{03DD}"),
1039 |     (b"gap", "\u{2A86}"),
1040 |     (b"gbreve", "\u{011F}"),
1041 |     (b"gcirc", "\u{011D}"),
1042 |     (b"gcy", "\u{0433}"),
1043 |     (b"gdot", "\u{0121}"),
1044 |     (b"ge", "\u{2265}"),
1045 |     (b"gel", "\u{22DB}"),
1046 |     (b"geq", "\u{2265}"),
1047 |     (b"geqq", "\u{2267}"),
1048 |     (b"geqslant", "\u{2A7E}"),
1049 |     (b"ges", "\u{2A7E}"),
1050 |     (b"gescc", "\u{2AA9}"),
1051 |     (b"gesdot", "\u{2A80}"),
1052 |     (b"gesdoto", "\u{2A82}"),
1053 |     (b"gesdotol", "\u{2A84}"),
1054 |     (b"gesl", "\u{22DB}"),
1055 |     (b"gesles", "\u{2A94}"),
1056 |     (b"gfr", "\u{1D524}"),
1057 |     (b"gg", "\u{226B}"),
1058 |     (b"ggg", "\u{22D9}"),
1059 |     (b"gimel", "\u{2137}"),
1060 |     (b"gjcy", "\u{0453}"),
1061 |     (b"gl", "\u{2277}"),
1062 |     (b"glE", "\u{2A92}"),
1063 |     (b"gla", "\u{2AA5}"),
1064 |     (b"glj", "\u{2AA4}"),
1065 |     (b"gnE", "\u{2269}"),
1066 |     (b"gnap", "\u{2A8A}"),
1067 |     (b"gnapprox", "\u{2A8A}"),
1068 |     (b"gne", "\u{2A88}"),
1069 |     (b"gneq", "\u{2A88}"),
1070 |     (b"gneqq", "\u{2269}"),
1071 |     (b"gnsim", "\u{22E7}"),
1072 |     (b"gopf", "\u{1D558}"),
1073 |     (b"grave", "\u{0060}"),
1074 |     (b"gscr", "\u{210A}"),
1075 |     (b"gsim", "\u{2273}"),
1076 |     (b"gsime", "\u{2A8E}"),
1077 |     (b"gsiml", "\u{2A90}"),
1078 |     (b"gt", "\u{003E}"),
1079 |     (b"gtcc", "\u{2AA7}"),
1080 |     (b"gtcir", "\u{2A7A}"),
1081 |     (b"gtdot", "\u{22D7}"),
1082 |     (b"gtlPar", "\u{2995}"),
1083 |     (b"gtquest", "\u{2A7C}"),
1084 |     (b"gtrapprox", "\u{2A86}"),
1085 |     (b"gtrarr", "\u{2978}"),
1086 |     (b"gtrdot", "\u{22D7}"),
1087 |     (b"gtreqless", "\u{22DB}"),
1088 |     (b"gtreqqless", "\u{2A8C}"),
1089 |     (b"gtrless", "\u{2277}"),
1090 |     (b"gtrsim", "\u{2273}"),
1091 |     (b"gvertneqq", "\u{2269}"),
1092 |     (b"gvnE", "\u{2269}"),
1093 |     (b"hArr", "\u{21D4}"),
1094 |     (b"hairsp", "\u{200A}"),
1095 |     (b"half", "\u{00BD}"),
1096 |     (b"hamilt", "\u{210B}"),
1097 |     (b"hardcy", "\u{044A}"),
1098 |     (b"harr", "\u{2194}"),
1099 |     (b"harrcir", "\u{2948}"),
1100 |     (b"harrw", "\u{21AD}"),
1101 |     (b"hbar", "\u{210F}"),
1102 |     (b"hcirc", "\u{0125}"),
1103 |     (b"hearts", "\u{2665}"),
1104 |     (b"heartsuit", "\u{2665}"),
1105 |     (b"hellip", "\u{2026}"),
1106 |     (b"hercon", "\u{22B9}"),
1107 |     (b"hfr", "\u{1D525}"),
1108 |     (b"hksearow", "\u{2925}"),
1109 |     (b"hkswarow", "\u{2926}"),
1110 |     (b"hoarr", "\u{21FF}"),
1111 |     (b"homtht", "\u{223B}"),
1112 |     (b"hookleftarrow", "\u{21A9}"),
1113 |     (b"hookrightarrow", "\u{21AA}"),
1114 |     (b"hopf", "\u{1D559}"),
1115 |     (b"horbar", "\u{2015}"),
1116 |     (b"hscr", "\u{1D4BD}"),
1117 |     (b"hslash", "\u{210F}"),
1118 |     (b"hstrok", "\u{0127}"),
1119 |     (b"hybull", "\u{2043}"),
1120 |     (b"hyphen", "\u{2010}"),
1121 |     (b"iacute", "\u{00ED}"),
1122 |     (b"ic", "\u{2063}"),
1123 |     (b"icirc", "\u{00EE}"),
1124 |     (b"icy", "\u{0438}"),
1125 |     (b"iecy", "\u{0435}"),
1126 |     (b"iexcl", "\u{00A1}"),
1127 |     (b"iff", "\u{21D4}"),
1128 |     (b"ifr", "\u{1D526}"),
1129 |     (b"igrave", "\u{00EC}"),
1130 |     (b"ii", "\u{2148}"),
1131 |     (b"iiiint", "\u{2A0C}"),
1132 |     (b"iiint", "\u{222D}"),
1133 |     (b"iinfin", "\u{29DC}"),
1134 |     (b"iiota", "\u{2129}"),
1135 |     (b"ijlig", "\u{0133}"),
1136 |     (b"imacr", "\u{012B}"),
1137 |     (b"image", "\u{2111}"),
1138 |     (b"imagline", "\u{2110}"),
1139 |     (b"imagpart", "\u{2111}"),
1140 |     (b"imath", "\u{0131}"),
1141 |     (b"imof", "\u{22B7}"),
1142 |     (b"imped", "\u{01B5}"),
1143 |     (b"in", "\u{2208}"),
1144 |     (b"incare", "\u{2105}"),
1145 |     (b"infin", "\u{221E}"),
1146 |     (b"infintie", "\u{29DD}"),
1147 |     (b"inodot", "\u{0131}"),
1148 |     (b"int", "\u{222B}"),
1149 |     (b"intcal", "\u{22BA}"),
1150 |     (b"integers", "\u{2124}"),
1151 |     (b"intercal", "\u{22BA}"),
1152 |     (b"intlarhk", "\u{2A17}"),
1153 |     (b"intprod", "\u{2A3C}"),
1154 |     (b"iocy", "\u{0451}"),
1155 |     (b"iogon", "\u{012F}"),
1156 |     (b"iopf", "\u{1D55A}"),
1157 |     (b"iota", "\u{03B9}"),
1158 |     (b"iprod", "\u{2A3C}"),
1159 |     (b"iquest", "\u{00BF}"),
1160 |     (b"iscr", "\u{1D4BE}"),
1161 |     (b"isin", "\u{2208}"),
1162 |     (b"isinE", "\u{22F9}"),
1163 |     (b"isindot", "\u{22F5}"),
1164 |     (b"isins", "\u{22F4}"),
1165 |     (b"isinsv", "\u{22F3}"),
1166 |     (b"isinv", "\u{2208}"),
1167 |     (b"it", "\u{2062}"),
1168 |     (b"itilde", "\u{0129}"),
1169 |     (b"iukcy", "\u{0456}"),
1170 |     (b"iuml", "\u{00EF}"),
1171 |     (b"jcirc", "\u{0135}"),
1172 |     (b"jcy", "\u{0439}"),
1173 |     (b"jfr", "\u{1D527}"),
1174 |     (b"jmath", "\u{0237}"),
1175 |     (b"jopf", "\u{1D55B}"),
1176 |     (b"jscr", "\u{1D4BF}"),
1177 |     (b"jsercy", "\u{0458}"),
1178 |     (b"jukcy", "\u{0454}"),
1179 |     (b"kappa", "\u{03BA}"),
1180 |     (b"kappav", "\u{03F0}"),
1181 |     (b"kcedil", "\u{0137}"),
1182 |     (b"kcy", "\u{043A}"),
1183 |     (b"kfr", "\u{1D528}"),
1184 |     (b"kgreen", "\u{0138}"),
1185 |     (b"khcy", "\u{0445}"),
1186 |     (b"kjcy", "\u{045C}"),
1187 |     (b"kopf", "\u{1D55C}"),
1188 |     (b"kscr", "\u{1D4C0}"),
1189 |     (b"lAarr", "\u{21DA}"),
1190 |     (b"lArr", "\u{21D0}"),
1191 |     (b"lAtail", "\u{291B}"),
1192 |     (b"lBarr", "\u{290E}"),
1193 |     (b"lE", "\u{2266}"),
1194 |     (b"lEg", "\u{2A8B}"),
1195 |     (b"lHar", "\u{2962}"),
1196 |     (b"lacute", "\u{013A}"),
1197 |     (b"laemptyv", "\u{29B4}"),
1198 |     (b"lagran", "\u{2112}"),
1199 |     (b"lambda", "\u{03BB}"),
1200 |     (b"lang", "\u{27E8}"),
1201 |     (b"langd", "\u{2991}"),
1202 |     (b"langle", "\u{27E8}"),
1203 |     (b"lap", "\u{2A85}"),
1204 |     (b"laquo", "\u{00AB}"),
1205 |     (b"larr", "\u{2190}"),
1206 |     (b"larrb", "\u{21E4}"),
1207 |     (b"larrbfs", "\u{291F}"),
1208 |     (b"larrfs", "\u{291D}"),
1209 |     (b"larrhk", "\u{21A9}"),
1210 |     (b"larrlp", "\u{21AB}"),
1211 |     (b"larrpl", "\u{2939}"),
1212 |     (b"larrsim", "\u{2973}"),
1213 |     (b"larrtl", "\u{21A2}"),
1214 |     (b"lat", "\u{2AAB}"),
1215 |     (b"latail", "\u{2919}"),
1216 |     (b"late", "\u{2AAD}"),
1217 |     (b"lates", "\u{2AAD}"),
1218 |     (b"lbarr", "\u{290C}"),
1219 |     (b"lbbrk", "\u{2772}"),
1220 |     (b"lbrace", "\u{007B}"),
1221 |     (b"lbrack", "\u{005B}"),
1222 |     (b"lbrke", "\u{298B}"),
1223 |     (b"lbrksld", "\u{298F}"),
1224 |     (b"lbrkslu", "\u{298D}"),
1225 |     (b"lcaron", "\u{013E}"),
1226 |     (b"lcedil", "\u{013C}"),
1227 |     (b"lceil", "\u{2308}"),
1228 |     (b"lcub", "\u{007B}"),
1229 |     (b"lcy", "\u{043B}"),
1230 |     (b"ldca", "\u{2936}"),
1231 |     (b"ldquo", "\u{201C}"),
1232 |     (b"ldquor", "\u{201E}"),
1233 |     (b"ldrdhar", "\u{2967}"),
1234 |     (b"ldrushar", "\u{294B}"),
1235 |     (b"ldsh", "\u{21B2}"),
1236 |     (b"le", "\u{2264}"),
1237 |     (b"leftarrow", "\u{2190}"),
1238 |     (b"leftarrowtail", "\u{21A2}"),
1239 |     (b"leftharpoondown", "\u{21BD}"),
1240 |     (b"leftharpoonup", "\u{21BC}"),
1241 |     (b"leftleftarrows", "\u{21C7}"),
1242 |     (b"leftrightarrow", "\u{2194}"),
1243 |     (b"leftrightarrows", "\u{21C6}"),
1244 |     (b"leftrightharpoons", "\u{21CB}"),
1245 |     (b"leftrightsquigarrow", "\u{21AD}"),
1246 |     (b"leftthreetimes", "\u{22CB}"),
1247 |     (b"leg", "\u{22DA}"),
1248 |     (b"leq", "\u{2264}"),
1249 |     (b"leqq", "\u{2266}"),
1250 |     (b"leqslant", "\u{2A7D}"),
1251 |     (b"les", "\u{2A7D}"),
1252 |     (b"lescc", "\u{2AA8}"),
1253 |     (b"lesdot", "\u{2A7F}"),
1254 |     (b"lesdoto", "\u{2A81}"),
1255 |     (b"lesdotor", "\u{2A83}"),
1256 |     (b"lesg", "\u{22DA}"),
1257 |     (b"lesges", "\u{2A93}"),
1258 |     (b"lessapprox", "\u{2A85}"),
1259 |     (b"lessdot", "\u{22D6}"),
1260 |     (b"lesseqgtr", "\u{22DA}"),
1261 |     (b"lesseqqgtr", "\u{2A8B}"),
1262 |     (b"lessgtr", "\u{2276}"),
1263 |     (b"lesssim", "\u{2272}"),
1264 |     (b"lfisht", "\u{297C}"),
1265 |     (b"lfloor", "\u{230A}"),
1266 |     (b"lfr", "\u{1D529}"),
1267 |     (b"lg", "\u{2276}"),
1268 |     (b"lgE", "\u{2A91}"),
1269 |     (b"lhard", "\u{21BD}"),
1270 |     (b"lharu", "\u{21BC}"),
1271 |     (b"lharul", "\u{296A}"),
1272 |     (b"lhblk", "\u{2584}"),
1273 |     (b"ljcy", "\u{0459}"),
1274 |     (b"ll", "\u{226A}"),
1275 |     (b"llarr", "\u{21C7}"),
1276 |     (b"llcorner", "\u{231E}"),
1277 |     (b"llhard", "\u{296B}"),
1278 |     (b"lltri", "\u{25FA}"),
1279 |     (b"lmidot", "\u{0140}"),
1280 |     (b"lmoust", "\u{23B0}"),
1281 |     (b"lmoustache", "\u{23B0}"),
1282 |     (b"lnE", "\u{2268}"),
1283 |     (b"lnap", "\u{2A89}"),
1284 |     (b"lnapprox", "\u{2A89}"),
1285 |     (b"lne", "\u{2A87}"),
1286 |     (b"lneq", "\u{2A87}"),
1287 |     (b"lneqq", "\u{2268}"),
1288 |     (b"lnsim", "\u{22E6}"),
1289 |     (b"loang", "\u{27EC}"),
1290 |     (b"loarr", "\u{21FD}"),
1291 |     (b"lobrk", "\u{27E6}"),
1292 |     (b"longleftarrow", "\u{27F5}"),
1293 |     (b"longleftrightarrow", "\u{27F7}"),
1294 |     (b"longmapsto", "\u{27FC}"),
1295 |     (b"longrightarrow", "\u{27F6}"),
1296 |     (b"looparrowleft", "\u{21AB}"),
1297 |     (b"looparrowright", "\u{21AC}"),
1298 |     (b"lopar", "\u{2985}"),
1299 |     (b"lopf", "\u{1D55D}"),
1300 |     (b"loplus", "\u{2A2D}"),
1301 |     (b"lotimes", "\u{2A34}"),
1302 |     (b"lowast", "\u{2217}"),
1303 |     (b"lowbar", "\u{005F}"),
1304 |     (b"loz", "\u{25CA}"),
1305 |     (b"lozenge", "\u{25CA}"),
1306 |     (b"lozf", "\u{29EB}"),
1307 |     (b"lpar", "\u{0028}"),
1308 |     (b"lparlt", "\u{2993}"),
1309 |     (b"lrarr", "\u{21C6}"),
1310 |     (b"lrcorner", "\u{231F}"),
1311 |     (b"lrhar", "\u{21CB}"),
1312 |     (b"lrhard", "\u{296D}"),
1313 |     (b"lrm", "\u{200E}"),
1314 |     (b"lrtri", "\u{22BF}"),
1315 |     (b"lsaquo", "\u{2039}"),
1316 |     (b"lscr", "\u{1D4C1}"),
1317 |     (b"lsh", "\u{21B0}"),
1318 |     (b"lsim", "\u{2272}"),
1319 |     (b"lsime", "\u{2A8D}"),
1320 |     (b"lsimg", "\u{2A8F}"),
1321 |     (b"lsqb", "\u{005B}"),
1322 |     (b"lsquo", "\u{2018}"),
1323 |     (b"lsquor", "\u{201A}"),
1324 |     (b"lstrok", "\u{0142}"),
1325 |     (b"lt", "\u{003C}"),
1326 |     (b"ltcc", "\u{2AA6}"),
1327 |     (b"ltcir", "\u{2A79}"),
1328 |     (b"ltdot", "\u{22D6}"),
1329 |     (b"lthree", "\u{22CB}"),
1330 |     (b"ltimes", "\u{22C9}"),
1331 |     (b"ltlarr", "\u{2976}"),
1332 |     (b"ltquest", "\u{2A7B}"),
1333 |     (b"ltrPar", "\u{2996}"),
1334 |     (b"ltri", "\u{25C3}"),
1335 |     (b"ltrie", "\u{22B4}"),
1336 |     (b"ltrif", "\u{25C2}"),
1337 |     (b"lurdshar", "\u{294A}"),
1338 |     (b"luruhar", "\u{2966}"),
1339 |     (b"lvertneqq", "\u{2268}"),
1340 |     (b"lvnE", "\u{2268}"),
1341 |     (b"mDDot", "\u{223A}"),
1342 |     (b"macr", "\u{00AF}"),
1343 |     (b"male", "\u{2642}"),
1344 |     (b"malt", "\u{2720}"),
1345 |     (b"maltese", "\u{2720}"),
1346 |     (b"map", "\u{21A6}"),
1347 |     (b"mapsto", "\u{21A6}"),
1348 |     (b"mapstodown", "\u{21A7}"),
1349 |     (b"mapstoleft", "\u{21A4}"),
1350 |     (b"mapstoup", "\u{21A5}"),
1351 |     (b"marker", "\u{25AE}"),
1352 |     (b"mcomma", "\u{2A29}"),
1353 |     (b"mcy", "\u{043C}"),
1354 |     (b"mdash", "\u{2014}"),
1355 |     (b"measuredangle", "\u{2221}"),
1356 |     (b"mfr", "\u{1D52A}"),
1357 |     (b"mho", "\u{2127}"),
1358 |     (b"micro", "\u{00B5}"),
1359 |     (b"mid", "\u{2223}"),
1360 |     (b"midast", "\u{002A}"),
1361 |     (b"midcir", "\u{2AF0}"),
1362 |     (b"middot", "\u{00B7}"),
1363 |     (b"minus", "\u{2212}"),
1364 |     (b"minusb", "\u{229F}"),
1365 |     (b"minusd", "\u{2238}"),
1366 |     (b"minusdu", "\u{2A2A}"),
1367 |     (b"mlcp", "\u{2ADB}"),
1368 |     (b"mldr", "\u{2026}"),
1369 |     (b"mnplus", "\u{2213}"),
1370 |     (b"models", "\u{22A7}"),
1371 |     (b"mopf", "\u{1D55E}"),
1372 |     (b"mp", "\u{2213}"),
1373 |     (b"mscr", "\u{1D4C2}"),
1374 |     (b"mstpos", "\u{223E}"),
1375 |     (b"mu", "\u{03BC}"),
1376 |     (b"multimap", "\u{22B8}"),
1377 |     (b"mumap", "\u{22B8}"),
1378 |     (b"nGg", "\u{22D9}"),
1379 |     (b"nGt", "\u{226B}"),
1380 |     (b"nGtv", "\u{226B}"),
1381 |     (b"nLeftarrow", "\u{21CD}"),
1382 |     (b"nLeftrightarrow", "\u{21CE}"),
1383 |     (b"nLl", "\u{22D8}"),
1384 |     (b"nLt", "\u{226A}"),
1385 |     (b"nLtv", "\u{226A}"),
1386 |     (b"nRightarrow", "\u{21CF}"),
1387 |     (b"nVDash", "\u{22AF}"),
1388 |     (b"nVdash", "\u{22AE}"),
1389 |     (b"nabla", "\u{2207}"),
1390 |     (b"nacute", "\u{0144}"),
1391 |     (b"nang", "\u{2220}"),
1392 |     (b"nap", "\u{2249}"),
1393 |     (b"napE", "\u{2A70}"),
1394 |     (b"napid", "\u{224B}"),
1395 |     (b"napos", "\u{0149}"),
1396 |     (b"napprox", "\u{2249}"),
1397 |     (b"natur", "\u{266E}"),
1398 |     (b"natural", "\u{266E}"),
1399 |     (b"naturals", "\u{2115}"),
1400 |     (b"nbsp", "\u{00A0}"),
1401 |     (b"nbump", "\u{224E}"),
1402 |     (b"nbumpe", "\u{224F}"),
1403 |     (b"ncap", "\u{2A43}"),
1404 |     (b"ncaron", "\u{0148}"),
1405 |     (b"ncedil", "\u{0146}"),
1406 |     (b"ncong", "\u{2247}"),
1407 |     (b"ncongdot", "\u{2A6D}"),
1408 |     (b"ncup", "\u{2A42}"),
1409 |     (b"ncy", "\u{043D}"),
1410 |     (b"ndash", "\u{2013}"),
1411 |     (b"ne", "\u{2260}"),
1412 |     (b"neArr", "\u{21D7}"),
1413 |     (b"nearhk", "\u{2924}"),
1414 |     (b"nearr", "\u{2197}"),
1415 |     (b"nearrow", "\u{2197}"),
1416 |     (b"nedot", "\u{2250}"),
1417 |     (b"nequiv", "\u{2262}"),
1418 |     (b"nesear", "\u{2928}"),
1419 |     (b"nesim", "\u{2242}"),
1420 |     (b"nexist", "\u{2204}"),
1421 |     (b"nexists", "\u{2204}"),
1422 |     (b"nfr", "\u{1D52B}"),
1423 |     (b"ngE", "\u{2267}"),
1424 |     (b"nge", "\u{2271}"),
1425 |     (b"ngeq", "\u{2271}"),
1426 |     (b"ngeqq", "\u{2267}"),
1427 |     (b"ngeqslant", "\u{2A7E}"),
1428 |     (b"nges", "\u{2A7E}"),
1429 |     (b"ngsim", "\u{2275}"),
1430 |     (b"ngt", "\u{226F}"),
1431 |     (b"ngtr", "\u{226F}"),
1432 |     (b"nhArr", "\u{21CE}"),
1433 |     (b"nharr", "\u{21AE}"),
1434 |     (b"nhpar", "\u{2AF2}"),
1435 |     (b"ni", "\u{220B}"),
1436 |     (b"nis", "\u{22FC}"),
1437 |     (b"nisd", "\u{22FA}"),
1438 |     (b"niv", "\u{220B}"),
1439 |     (b"njcy", "\u{045A}"),
1440 |     (b"nlArr", "\u{21CD}"),
1441 |     (b"nlE", "\u{2266}"),
1442 |     (b"nlarr", "\u{219A}"),
1443 |     (b"nldr", "\u{2025}"),
1444 |     (b"nle", "\u{2270}"),
1445 |     (b"nleftarrow", "\u{219A}"),
1446 |     (b"nleftrightarrow", "\u{21AE}"),
1447 |     (b"nleq", "\u{2270}"),
1448 |     (b"nleqq", "\u{2266}"),
1449 |     (b"nleqslant", "\u{2A7D}"),
1450 |     (b"nles", "\u{2A7D}"),
1451 |     (b"nless", "\u{226E}"),
1452 |     (b"nlsim", "\u{2274}"),
1453 |     (b"nlt", "\u{226E}"),
1454 |     (b"nltri", "\u{22EA}"),
1455 |     (b"nltrie", "\u{22EC}"),
1456 |     (b"nmid", "\u{2224}"),
1457 |     (b"nopf", "\u{1D55F}"),
1458 |     (b"not", "\u{00AC}"),
1459 |     (b"notin", "\u{2209}"),
1460 |     (b"notinE", "\u{22F9}"),
1461 |     (b"notindot", "\u{22F5}"),
1462 |     (b"notinva", "\u{2209}"),
1463 |     (b"notinvb", "\u{22F7}"),
1464 |     (b"notinvc", "\u{22F6}"),
1465 |     (b"notni", "\u{220C}"),
1466 |     (b"notniva", "\u{220C}"),
1467 |     (b"notnivb", "\u{22FE}"),
1468 |     (b"notnivc", "\u{22FD}"),
1469 |     (b"npar", "\u{2226}"),
1470 |     (b"nparallel", "\u{2226}"),
1471 |     (b"nparsl", "\u{2AFD}"),
1472 |     (b"npart", "\u{2202}"),
1473 |     (b"npolint", "\u{2A14}"),
1474 |     (b"npr", "\u{2280}"),
1475 |     (b"nprcue", "\u{22E0}"),
1476 |     (b"npre", "\u{2AAF}"),
1477 |     (b"nprec", "\u{2280}"),
1478 |     (b"npreceq", "\u{2AAF}"),
1479 |     (b"nrArr", "\u{21CF}"),
1480 |     (b"nrarr", "\u{219B}"),
1481 |     (b"nrarrc", "\u{2933}"),
1482 |     (b"nrarrw", "\u{219D}"),
1483 |     (b"nrightarrow", "\u{219B}"),
1484 |     (b"nrtri", "\u{22EB}"),
1485 |     (b"nrtrie", "\u{22ED}"),
1486 |     (b"nsc", "\u{2281}"),
1487 |     (b"nsccue", "\u{22E1}"),
1488 |     (b"nsce", "\u{2AB0}"),
1489 |     (b"nscr", "\u{1D4C3}"),
1490 |     (b"nshortmid", "\u{2224}"),
1491 |     (b"nshortparallel", "\u{2226}"),
1492 |     (b"nsim", "\u{2241}"),
1493 |     (b"nsime", "\u{2244}"),
1494 |     (b"nsimeq", "\u{2244}"),
1495 |     (b"nsmid", "\u{2224}"),
1496 |     (b"nspar", "\u{2226}"),
1497 |     (b"nsqsube", "\u{22E2}"),
1498 |     (b"nsqsupe", "\u{22E3}"),
1499 |     (b"nsub", "\u{2284}"),
1500 |     (b"nsubE", "\u{2AC5}"),
1501 |     (b"nsube", "\u{2288}"),
1502 |     (b"nsubset", "\u{2282}"),
1503 |     (b"nsubseteq", "\u{2288}"),
1504 |     (b"nsubseteqq", "\u{2AC5}"),
1505 |     (b"nsucc", "\u{2281}"),
1506 |     (b"nsucceq", "\u{2AB0}"),
1507 |     (b"nsup", "\u{2285}"),
1508 |     (b"nsupE", "\u{2AC6}"),
1509 |     (b"nsupe", "\u{2289}"),
1510 |     (b"nsupset", "\u{2283}"),
1511 |     (b"nsupseteq", "\u{2289}"),
1512 |     (b"nsupseteqq", "\u{2AC6}"),
1513 |     (b"ntgl", "\u{2279}"),
1514 |     (b"ntilde", "\u{00F1}"),
1515 |     (b"ntlg", "\u{2278}"),
1516 |     (b"ntriangleleft", "\u{22EA}"),
1517 |     (b"ntrianglelefteq", "\u{22EC}"),
1518 |     (b"ntriangleright", "\u{22EB}"),
1519 |     (b"ntrianglerighteq", "\u{22ED}"),
1520 |     (b"nu", "\u{03BD}"),
1521 |     (b"num", "\u{0023}"),
1522 |     (b"numero", "\u{2116}"),
1523 |     (b"numsp", "\u{2007}"),
1524 |     (b"nvDash", "\u{22AD}"),
1525 |     (b"nvHarr", "\u{2904}"),
1526 |     (b"nvap", "\u{224D}"),
1527 |     (b"nvdash", "\u{22AC}"),
1528 |     (b"nvge", "\u{2265}"),
1529 |     (b"nvgt", "\u{003E}"),
1530 |     (b"nvinfin", "\u{29DE}"),
1531 |     (b"nvlArr", "\u{2902}"),
1532 |     (b"nvle", "\u{2264}"),
1533 |     (b"nvlt", "\u{003C}"),
1534 |     (b"nvltrie", "\u{22B4}"),
1535 |     (b"nvrArr", "\u{2903}"),
1536 |     (b"nvrtrie", "\u{22B5}"),
1537 |     (b"nvsim", "\u{223C}"),
1538 |     (b"nwArr", "\u{21D6}"),
1539 |     (b"nwarhk", "\u{2923}"),
1540 |     (b"nwarr", "\u{2196}"),
1541 |     (b"nwarrow", "\u{2196}"),
1542 |     (b"nwnear", "\u{2927}"),
1543 |     (b"oS", "\u{24C8}"),
1544 |     (b"oacute", "\u{00F3}"),
1545 |     (b"oast", "\u{229B}"),
1546 |     (b"ocir", "\u{229A}"),
1547 |     (b"ocirc", "\u{00F4}"),
1548 |     (b"ocy", "\u{043E}"),
1549 |     (b"odash", "\u{229D}"),
1550 |     (b"odblac", "\u{0151}"),
1551 |     (b"odiv", "\u{2A38}"),
1552 |     (b"odot", "\u{2299}"),
1553 |     (b"odsold", "\u{29BC}"),
1554 |     (b"oelig", "\u{0153}"),
1555 |     (b"ofcir", "\u{29BF}"),
1556 |     (b"ofr", "\u{1D52C}"),
1557 |     (b"ogon", "\u{02DB}"),
1558 |     (b"ograve", "\u{00F2}"),
1559 |     (b"ogt", "\u{29C1}"),
1560 |     (b"ohbar", "\u{29B5}"),
1561 |     (b"ohm", "\u{03A9}"),
1562 |     (b"oint", "\u{222E}"),
1563 |     (b"olarr", "\u{21BA}"),
1564 |     (b"olcir", "\u{29BE}"),
1565 |     (b"olcross", "\u{29BB}"),
1566 |     (b"oline", "\u{203E}"),
1567 |     (b"olt", "\u{29C0}"),
1568 |     (b"omacr", "\u{014D}"),
1569 |     (b"omega", "\u{03C9}"),
1570 |     (b"omicron", "\u{03BF}"),
1571 |     (b"omid", "\u{29B6}"),
1572 |     (b"ominus", "\u{2296}"),
1573 |     (b"oopf", "\u{1D560}"),
1574 |     (b"opar", "\u{29B7}"),
1575 |     (b"operp", "\u{29B9}"),
1576 |     (b"oplus", "\u{2295}"),
1577 |     (b"or", "\u{2228}"),
1578 |     (b"orarr", "\u{21BB}"),
1579 |     (b"ord", "\u{2A5D}"),
1580 |     (b"order", "\u{2134}"),
1581 |     (b"orderof", "\u{2134}"),
1582 |     (b"ordf", "\u{00AA}"),
1583 |     (b"ordm", "\u{00BA}"),
1584 |     (b"origof", "\u{22B6}"),
1585 |     (b"oror", "\u{2A56}"),
1586 |     (b"orslope", "\u{2A57}"),
1587 |     (b"orv", "\u{2A5B}"),
1588 |     (b"oscr", "\u{2134}"),
1589 |     (b"oslash", "\u{00F8}"),
1590 |     (b"osol", "\u{2298}"),
1591 |     (b"otilde", "\u{00F5}"),
1592 |     (b"otimes", "\u{2297}"),
1593 |     (b"otimesas", "\u{2A36}"),
1594 |     (b"ouml", "\u{00F6}"),
1595 |     (b"ovbar", "\u{233D}"),
1596 |     (b"par", "\u{2225}"),
1597 |     (b"para", "\u{00B6}"),
1598 |     (b"parallel", "\u{2225}"),
1599 |     (b"parsim", "\u{2AF3}"),
1600 |     (b"parsl", "\u{2AFD}"),
1601 |     (b"part", "\u{2202}"),
1602 |     (b"pcy", "\u{043F}"),
1603 |     (b"percnt", "\u{0025}"),
1604 |     (b"period", "\u{002E}"),
1605 |     (b"permil", "\u{2030}"),
1606 |     (b"perp", "\u{22A5}"),
1607 |     (b"pertenk", "\u{2031}"),
1608 |     (b"pfr", "\u{1D52D}"),
1609 |     (b"phi", "\u{03C6}"),
1610 |     (b"phiv", "\u{03D5}"),
1611 |     (b"phmmat", "\u{2133}"),
1612 |     (b"phone", "\u{260E}"),
1613 |     (b"pi", "\u{03C0}"),
1614 |     (b"pitchfork", "\u{22D4}"),
1615 |     (b"piv", "\u{03D6}"),
1616 |     (b"planck", "\u{210F}"),
1617 |     (b"planckh", "\u{210E}"),
1618 |     (b"plankv", "\u{210F}"),
1619 |     (b"plus", "\u{002B}"),
1620 |     (b"plusacir", "\u{2A23}"),
1621 |     (b"plusb", "\u{229E}"),
1622 |     (b"pluscir", "\u{2A22}"),
1623 |     (b"plusdo", "\u{2214}"),
1624 |     (b"plusdu", "\u{2A25}"),
1625 |     (b"pluse", "\u{2A72}"),
1626 |     (b"plusmn", "\u{00B1}"),
1627 |     (b"plussim", "\u{2A26}"),
1628 |     (b"plustwo", "\u{2A27}"),
1629 |     (b"pm", "\u{00B1}"),
1630 |     (b"pointint", "\u{2A15}"),
1631 |     (b"popf", "\u{1D561}"),
1632 |     (b"pound", "\u{00A3}"),
1633 |     (b"pr", "\u{227A}"),
1634 |     (b"prE", "\u{2AB3}"),
1635 |     (b"prap", "\u{2AB7}"),
1636 |     (b"prcue", "\u{227C}"),
1637 |     (b"pre", "\u{2AAF}"),
1638 |     (b"prec", "\u{227A}"),
1639 |     (b"precapprox", "\u{2AB7}"),
1640 |     (b"preccurlyeq", "\u{227C}"),
1641 |     (b"preceq", "\u{2AAF}"),
1642 |     (b"precnapprox", "\u{2AB9}"),
1643 |     (b"precneqq", "\u{2AB5}"),
1644 |     (b"precnsim", "\u{22E8}"),
1645 |     (b"precsim", "\u{227E}"),
1646 |     (b"prime", "\u{2032}"),
1647 |     (b"primes", "\u{2119}"),
1648 |     (b"prnE", "\u{2AB5}"),
1649 |     (b"prnap", "\u{2AB9}"),
1650 |     (b"prnsim", "\u{22E8}"),
1651 |     (b"prod", "\u{220F}"),
1652 |     (b"profalar", "\u{232E}"),
1653 |     (b"profline", "\u{2312}"),
1654 |     (b"profsurf", "\u{2313}"),
1655 |     (b"prop", "\u{221D}"),
1656 |     (b"propto", "\u{221D}"),
1657 |     (b"prsim", "\u{227E}"),
1658 |     (b"prurel", "\u{22B0}"),
1659 |     (b"pscr", "\u{1D4C5}"),
1660 |     (b"psi", "\u{03C8}"),
1661 |     (b"puncsp", "\u{2008}"),
1662 |     (b"qfr", "\u{1D52E}"),
1663 |     (b"qint", "\u{2A0C}"),
1664 |     (b"qopf", "\u{1D562}"),
1665 |     (b"qprime", "\u{2057}"),
1666 |     (b"qscr", "\u{1D4C6}"),
1667 |     (b"quaternions", "\u{210D}"),
1668 |     (b"quatint", "\u{2A16}"),
1669 |     (b"quest", "\u{003F}"),
1670 |     (b"questeq", "\u{225F}"),
1671 |     (b"quot", "\u{0022}"),
1672 |     (b"rAarr", "\u{21DB}"),
1673 |     (b"rArr", "\u{21D2}"),
1674 |     (b"rAtail", "\u{291C}"),
1675 |     (b"rBarr", "\u{290F}"),
1676 |     (b"rHar", "\u{2964}"),
1677 |     (b"race", "\u{223D}"),
1678 |     (b"racute", "\u{0155}"),
1679 |     (b"radic", "\u{221A}"),
1680 |     (b"raemptyv", "\u{29B3}"),
1681 |     (b"rang", "\u{27E9}"),
1682 |     (b"rangd", "\u{2992}"),
1683 |     (b"range", "\u{29A5}"),
1684 |     (b"rangle", "\u{27E9}"),
1685 |     (b"raquo", "\u{00BB}"),
1686 |     (b"rarr", "\u{2192}"),
1687 |     (b"rarrap", "\u{2975}"),
1688 |     (b"rarrb", "\u{21E5}"),
1689 |     (b"rarrbfs", "\u{2920}"),
1690 |     (b"rarrc", "\u{2933}"),
1691 |     (b"rarrfs", "\u{291E}"),
1692 |     (b"rarrhk", "\u{21AA}"),
1693 |     (b"rarrlp", "\u{21AC}"),
1694 |     (b"rarrpl", "\u{2945}"),
1695 |     (b"rarrsim", "\u{2974}"),
1696 |     (b"rarrtl", "\u{21A3}"),
1697 |     (b"rarrw", "\u{219D}"),
1698 |     (b"ratail", "\u{291A}"),
1699 |     (b"ratio", "\u{2236}"),
1700 |     (b"rationals", "\u{211A}"),
1701 |     (b"rbarr", "\u{290D}"),
1702 |     (b"rbbrk", "\u{2773}"),
1703 |     (b"rbrace", "\u{007D}"),
1704 |     (b"rbrack", "\u{005D}"),
1705 |     (b"rbrke", "\u{298C}"),
1706 |     (b"rbrksld", "\u{298E}"),
1707 |     (b"rbrkslu", "\u{2990}"),
1708 |     (b"rcaron", "\u{0159}"),
1709 |     (b"rcedil", "\u{0157}"),
1710 |     (b"rceil", "\u{2309}"),
1711 |     (b"rcub", "\u{007D}"),
1712 |     (b"rcy", "\u{0440}"),
1713 |     (b"rdca", "\u{2937}"),
1714 |     (b"rdldhar", "\u{2969}"),
1715 |     (b"rdquo", "\u{201D}"),
1716 |     (b"rdquor", "\u{201D}"),
1717 |     (b"rdsh", "\u{21B3}"),
1718 |     (b"real", "\u{211C}"),
1719 |     (b"realine", "\u{211B}"),
1720 |     (b"realpart", "\u{211C}"),
1721 |     (b"reals", "\u{211D}"),
1722 |     (b"rect", "\u{25AD}"),
1723 |     (b"reg", "\u{00AE}"),
1724 |     (b"rfisht", "\u{297D}"),
1725 |     (b"rfloor", "\u{230B}"),
1726 |     (b"rfr", "\u{1D52F}"),
1727 |     (b"rhard", "\u{21C1}"),
1728 |     (b"rharu", "\u{21C0}"),
1729 |     (b"rharul", "\u{296C}"),
1730 |     (b"rho", "\u{03C1}"),
1731 |     (b"rhov", "\u{03F1}"),
1732 |     (b"rightarrow", "\u{2192}"),
1733 |     (b"rightarrowtail", "\u{21A3}"),
1734 |     (b"rightharpoondown", "\u{21C1}"),
1735 |     (b"rightharpoonup", "\u{21C0}"),
1736 |     (b"rightleftarrows", "\u{21C4}"),
1737 |     (b"rightleftharpoons", "\u{21CC}"),
1738 |     (b"rightrightarrows", "\u{21C9}"),
1739 |     (b"rightsquigarrow", "\u{219D}"),
1740 |     (b"rightthreetimes", "\u{22CC}"),
1741 |     (b"ring", "\u{02DA}"),
1742 |     (b"risingdotseq", "\u{2253}"),
1743 |     (b"rlarr", "\u{21C4}"),
1744 |     (b"rlhar", "\u{21CC}"),
1745 |     (b"rlm", "\u{200F}"),
1746 |     (b"rmoust", "\u{23B1}"),
1747 |     (b"rmoustache", "\u{23B1}"),
1748 |     (b"rnmid", "\u{2AEE}"),
1749 |     (b"roang", "\u{27ED}"),
1750 |     (b"roarr", "\u{21FE}"),
1751 |     (b"robrk", "\u{27E7}"),
1752 |     (b"ropar", "\u{2986}"),
1753 |     (b"ropf", "\u{1D563}"),
1754 |     (b"roplus", "\u{2A2E}"),
1755 |     (b"rotimes", "\u{2A35}"),
1756 |     (b"rpar", "\u{0029}"),
1757 |     (b"rpargt", "\u{2994}"),
1758 |     (b"rppolint", "\u{2A12}"),
1759 |     (b"rrarr", "\u{21C9}"),
1760 |     (b"rsaquo", "\u{203A}"),
1761 |     (b"rscr", "\u{1D4C7}"),
1762 |     (b"rsh", "\u{21B1}"),
1763 |     (b"rsqb", "\u{005D}"),
1764 |     (b"rsquo", "\u{2019}"),
1765 |     (b"rsquor", "\u{2019}"),
1766 |     (b"rthree", "\u{22CC}"),
1767 |     (b"rtimes", "\u{22CA}"),
1768 |     (b"rtri", "\u{25B9}"),
1769 |     (b"rtrie", "\u{22B5}"),
1770 |     (b"rtrif", "\u{25B8}"),
1771 |     (b"rtriltri", "\u{29CE}"),
1772 |     (b"ruluhar", "\u{2968}"),
1773 |     (b"rx", "\u{211E}"),
1774 |     (b"sacute", "\u{015B}"),
1775 |     (b"sbquo", "\u{201A}"),
1776 |     (b"sc", "\u{227B}"),
1777 |     (b"scE", "\u{2AB4}"),
1778 |     (b"scap", "\u{2AB8}"),
1779 |     (b"scaron", "\u{0161}"),
1780 |     (b"sccue", "\u{227D}"),
1781 |     (b"sce", "\u{2AB0}"),
1782 |     (b"scedil", "\u{015F}"),
1783 |     (b"scirc", "\u{015D}"),
1784 |     (b"scnE", "\u{2AB6}"),
1785 |     (b"scnap", "\u{2ABA}"),
1786 |     (b"scnsim", "\u{22E9}"),
1787 |     (b"scpolint", "\u{2A13}"),
1788 |     (b"scsim", "\u{227F}"),
1789 |     (b"scy", "\u{0441}"),
1790 |     (b"sdot", "\u{22C5}"),
1791 |     (b"sdotb", "\u{22A1}"),
1792 |     (b"sdote", "\u{2A66}"),
1793 |     (b"seArr", "\u{21D8}"),
1794 |     (b"searhk", "\u{2925}"),
1795 |     (b"searr", "\u{2198}"),
1796 |     (b"searrow", "\u{2198}"),
1797 |     (b"sect", "\u{00A7}"),
1798 |     (b"semi", "\u{003B}"),
1799 |     (b"seswar", "\u{2929}"),
1800 |     (b"setminus", "\u{2216}"),
1801 |     (b"setmn", "\u{2216}"),
1802 |     (b"sext", "\u{2736}"),
1803 |     (b"sfr", "\u{1D530}"),
1804 |     (b"sfrown", "\u{2322}"),
1805 |     (b"sharp", "\u{266F}"),
1806 |     (b"shchcy", "\u{0449}"),
1807 |     (b"shcy", "\u{0448}"),
1808 |     (b"shortmid", "\u{2223}"),
1809 |     (b"shortparallel", "\u{2225}"),
1810 |     (b"shy", "\u{00AD}"),
1811 |     (b"sigma", "\u{03C3}"),
1812 |     (b"sigmaf", "\u{03C2}"),
1813 |     (b"sigmav", "\u{03C2}"),
1814 |     (b"sim", "\u{223C}"),
1815 |     (b"simdot", "\u{2A6A}"),
1816 |     (b"sime", "\u{2243}"),
1817 |     (b"simeq", "\u{2243}"),
1818 |     (b"simg", "\u{2A9E}"),
1819 |     (b"simgE", "\u{2AA0}"),
1820 |     (b"siml", "\u{2A9D}"),
1821 |     (b"simlE", "\u{2A9F}"),
1822 |     (b"simne", "\u{2246}"),
1823 |     (b"simplus", "\u{2A24}"),
1824 |     (b"simrarr", "\u{2972}"),
1825 |     (b"slarr", "\u{2190}"),
1826 |     (b"smallsetminus", "\u{2216}"),
1827 |     (b"smashp", "\u{2A33}"),
1828 |     (b"smeparsl", "\u{29E4}"),
1829 |     (b"smid", "\u{2223}"),
1830 |     (b"smile", "\u{2323}"),
1831 |     (b"smt", "\u{2AAA}"),
1832 |     (b"smte", "\u{2AAC}"),
1833 |     (b"smtes", "\u{2AAC}"),
1834 |     (b"softcy", "\u{044C}"),
1835 |     (b"sol", "\u{002F}"),
1836 |     (b"solb", "\u{29C4}"),
1837 |     (b"solbar", "\u{233F}"),
1838 |     (b"sopf", "\u{1D564}"),
1839 |     (b"spades", "\u{2660}"),
1840 |     (b"spadesuit", "\u{2660}"),
1841 |     (b"spar", "\u{2225}"),
1842 |     (b"sqcap", "\u{2293}"),
1843 |     (b"sqcaps", "\u{2293}"),
1844 |     (b"sqcup", "\u{2294}"),
1845 |     (b"sqcups", "\u{2294}"),
1846 |     (b"sqsub", "\u{228F}"),
1847 |     (b"sqsube", "\u{2291}"),
1848 |     (b"sqsubset", "\u{228F}"),
1849 |     (b"sqsubseteq", "\u{2291}"),
1850 |     (b"sqsup", "\u{2290}"),
1851 |     (b"sqsupe", "\u{2292}"),
1852 |     (b"sqsupset", "\u{2290}"),
1853 |     (b"sqsupseteq", "\u{2292}"),
1854 |     (b"squ", "\u{25A1}"),
1855 |     (b"square", "\u{25A1}"),
1856 |     (b"squarf", "\u{25AA}"),
1857 |     (b"squf", "\u{25AA}"),
1858 |     (b"srarr", "\u{2192}"),
1859 |     (b"sscr", "\u{1D4C8}"),
1860 |     (b"ssetmn", "\u{2216}"),
1861 |     (b"ssmile", "\u{2323}"),
1862 |     (b"sstarf", "\u{22C6}"),
1863 |     (b"star", "\u{2606}"),
1864 |     (b"starf", "\u{2605}"),
1865 |     (b"straightepsilon", "\u{03F5}"),
1866 |     (b"straightphi", "\u{03D5}"),
1867 |     (b"strns", "\u{00AF}"),
1868 |     (b"sub", "\u{2282}"),
1869 |     (b"subE", "\u{2AC5}"),
1870 |     (b"subdot", "\u{2ABD}"),
1871 |     (b"sube", "\u{2286}"),
1872 |     (b"subedot", "\u{2AC3}"),
1873 |     (b"submult", "\u{2AC1}"),
1874 |     (b"subnE", "\u{2ACB}"),
1875 |     (b"subne", "\u{228A}"),
1876 |     (b"subplus", "\u{2ABF}"),
1877 |     (b"subrarr", "\u{2979}"),
1878 |     (b"subset", "\u{2282}"),
1879 |     (b"subseteq", "\u{2286}"),
1880 |     (b"subseteqq", "\u{2AC5}"),
1881 |     (b"subsetneq", "\u{228A}"),
1882 |     (b"subsetneqq", "\u{2ACB}"),
1883 |     (b"subsim", "\u{2AC7}"),
1884 |     (b"subsub", "\u{2AD5}"),
1885 |     (b"subsup", "\u{2AD3}"),
1886 |     (b"succ", "\u{227B}"),
1887 |     (b"succapprox", "\u{2AB8}"),
1888 |     (b"succcurlyeq", "\u{227D}"),
1889 |     (b"succeq", "\u{2AB0}"),
1890 |     (b"succnapprox", "\u{2ABA}"),
1891 |     (b"succneqq", "\u{2AB6}"),
1892 |     (b"succnsim", "\u{22E9}"),
1893 |     (b"succsim", "\u{227F}"),
1894 |     (b"sum", "\u{2211}"),
1895 |     (b"sung", "\u{266A}"),
1896 |     (b"sup", "\u{2283}"),
1897 |     (b"sup1", "\u{00B9}"),
1898 |     (b"sup2", "\u{00B2}"),
1899 |     (b"sup3", "\u{00B3}"),
1900 |     (b"supE", "\u{2AC6}"),
1901 |     (b"supdot", "\u{2ABE}"),
1902 |     (b"supdsub", "\u{2AD8}"),
1903 |     (b"supe", "\u{2287}"),
1904 |     (b"supedot", "\u{2AC4}"),
1905 |     (b"suphsol", "\u{27C9}"),
1906 |     (b"suphsub", "\u{2AD7}"),
1907 |     (b"suplarr", "\u{297B}"),
1908 |     (b"supmult", "\u{2AC2}"),
1909 |     (b"supnE", "\u{2ACC}"),
1910 |     (b"supne", "\u{228B}"),
1911 |     (b"supplus", "\u{2AC0}"),
1912 |     (b"supset", "\u{2283}"),
1913 |     (b"supseteq", "\u{2287}"),
1914 |     (b"supseteqq", "\u{2AC6}"),
1915 |     (b"supsetneq", "\u{228B}"),
1916 |     (b"supsetneqq", "\u{2ACC}"),
1917 |     (b"supsim", "\u{2AC8}"),
1918 |     (b"supsub", "\u{2AD4}"),
1919 |     (b"supsup", "\u{2AD6}"),
1920 |     (b"swArr", "\u{21D9}"),
1921 |     (b"swarhk", "\u{2926}"),
1922 |     (b"swarr", "\u{2199}"),
1923 |     (b"swarrow", "\u{2199}"),
1924 |     (b"swnwar", "\u{292A}"),
1925 |     (b"szlig", "\u{00DF}"),
1926 |     (b"target", "\u{2316}"),
1927 |     (b"tau", "\u{03C4}"),
1928 |     (b"tbrk", "\u{23B4}"),
1929 |     (b"tcaron", "\u{0165}"),
1930 |     (b"tcedil", "\u{0163}"),
1931 |     (b"tcy", "\u{0442}"),
1932 |     (b"tdot", "\u{20DB}"),
1933 |     (b"telrec", "\u{2315}"),
1934 |     (b"tfr", "\u{1D531}"),
1935 |     (b"there4", "\u{2234}"),
1936 |     (b"therefore", "\u{2234}"),
1937 |     (b"theta", "\u{03B8}"),
1938 |     (b"thetasym", "\u{03D1}"),
1939 |     (b"thetav", "\u{03D1}"),
1940 |     (b"thickapprox", "\u{2248}"),
1941 |     (b"thicksim", "\u{223C}"),
1942 |     (b"thinsp", "\u{2009}"),
1943 |     (b"thkap", "\u{2248}"),
1944 |     (b"thksim", "\u{223C}"),
1945 |     (b"thorn", "\u{00FE}"),
1946 |     (b"tilde", "\u{02DC}"),
1947 |     (b"times", "\u{00D7}"),
1948 |     (b"timesb", "\u{22A0}"),
1949 |     (b"timesbar", "\u{2A31}"),
1950 |     (b"timesd", "\u{2A30}"),
1951 |     (b"tint", "\u{222D}"),
1952 |     (b"toea", "\u{2928}"),
1953 |     (b"top", "\u{22A4}"),
1954 |     (b"topbot", "\u{2336}"),
1955 |     (b"topcir", "\u{2AF1}"),
1956 |     (b"topf", "\u{1D565}"),
1957 |     (b"topfork", "\u{2ADA}"),
1958 |     (b"tosa", "\u{2929}"),
1959 |     (b"tprime", "\u{2034}"),
1960 |     (b"trade", "\u{2122}"),
1961 |     (b"triangle", "\u{25B5}"),
1962 |     (b"triangledown", "\u{25BF}"),
1963 |     (b"triangleleft", "\u{25C3}"),
1964 |     (b"trianglelefteq", "\u{22B4}"),
1965 |     (b"triangleq", "\u{225C}"),
1966 |     (b"triangleright", "\u{25B9}"),
1967 |     (b"trianglerighteq", "\u{22B5}"),
1968 |     (b"tridot", "\u{25EC}"),
1969 |     (b"trie", "\u{225C}"),
1970 |     (b"triminus", "\u{2A3A}"),
1971 |     (b"triplus", "\u{2A39}"),
1972 |     (b"trisb", "\u{29CD}"),
1973 |     (b"tritime", "\u{2A3B}"),
1974 |     (b"trpezium", "\u{23E2}"),
1975 |     (b"tscr", "\u{1D4C9}"),
1976 |     (b"tscy", "\u{0446}"),
1977 |     (b"tshcy", "\u{045B}"),
1978 |     (b"tstrok", "\u{0167}"),
1979 |     (b"twixt", "\u{226C}"),
1980 |     (b"twoheadleftarrow", "\u{219E}"),
1981 |     (b"twoheadrightarrow", "\u{21A0}"),
1982 |     (b"uArr", "\u{21D1}"),
1983 |     (b"uHar", "\u{2963}"),
1984 |     (b"uacute", "\u{00FA}"),
1985 |     (b"uarr", "\u{2191}"),
1986 |     (b"ubrcy", "\u{045E}"),
1987 |     (b"ubreve", "\u{016D}"),
1988 |     (b"ucirc", "\u{00FB}"),
1989 |     (b"ucy", "\u{0443}"),
1990 |     (b"udarr", "\u{21C5}"),
1991 |     (b"udblac", "\u{0171}"),
1992 |     (b"udhar", "\u{296E}"),
1993 |     (b"ufisht", "\u{297E}"),
1994 |     (b"ufr", "\u{1D532}"),
1995 |     (b"ugrave", "\u{00F9}"),
1996 |     (b"uharl", "\u{21BF}"),
1997 |     (b"uharr", "\u{21BE}"),
1998 |     (b"uhblk", "\u{2580}"),
1999 |     (b"ulcorn", "\u{231C}"),
2000 |     (b"ulcorner", "\u{231C}"),
2001 |     (b"ulcrop", "\u{230F}"),
2002 |     (b"ultri", "\u{25F8}"),
2003 |     (b"umacr", "\u{016B}"),
2004 |     (b"uml", "\u{00A8}"),
2005 |     (b"uogon", "\u{0173}"),
2006 |     (b"uopf", "\u{1D566}"),
2007 |     (b"uparrow", "\u{2191}"),
2008 |     (b"updownarrow", "\u{2195}"),
2009 |     (b"upharpoonleft", "\u{21BF}"),
2010 |     (b"upharpoonright", "\u{21BE}"),
2011 |     (b"uplus", "\u{228E}"),
2012 |     (b"upsi", "\u{03C5}"),
2013 |     (b"upsih", "\u{03D2}"),
2014 |     (b"upsilon", "\u{03C5}"),
2015 |     (b"upuparrows", "\u{21C8}"),
2016 |     (b"urcorn", "\u{231D}"),
2017 |     (b"urcorner", "\u{231D}"),
2018 |     (b"urcrop", "\u{230E}"),
2019 |     (b"uring", "\u{016F}"),
2020 |     (b"urtri", "\u{25F9}"),
2021 |     (b"uscr", "\u{1D4CA}"),
2022 |     (b"utdot", "\u{22F0}"),
2023 |     (b"utilde", "\u{0169}"),
2024 |     (b"utri", "\u{25B5}"),
2025 |     (b"utrif", "\u{25B4}"),
2026 |     (b"uuarr", "\u{21C8}"),
2027 |     (b"uuml", "\u{00FC}"),
2028 |     (b"uwangle", "\u{29A7}"),
2029 |     (b"vArr", "\u{21D5}"),
2030 |     (b"vBar", "\u{2AE8}"),
2031 |     (b"vBarv", "\u{2AE9}"),
2032 |     (b"vDash", "\u{22A8}"),
2033 |     (b"vangrt", "\u{299C}"),
2034 |     (b"varepsilon", "\u{03F5}"),
2035 |     (b"varkappa", "\u{03F0}"),
2036 |     (b"varnothing", "\u{2205}"),
2037 |     (b"varphi", "\u{03D5}"),
2038 |     (b"varpi", "\u{03D6}"),
2039 |     (b"varpropto", "\u{221D}"),
2040 |     (b"varr", "\u{2195}"),
2041 |     (b"varrho", "\u{03F1}"),
2042 |     (b"varsigma", "\u{03C2}"),
2043 |     (b"varsubsetneq", "\u{228A}"),
2044 |     (b"varsubsetneqq", "\u{2ACB}"),
2045 |     (b"varsupsetneq", "\u{228B}"),
2046 |     (b"varsupsetneqq", "\u{2ACC}"),
2047 |     (b"vartheta", "\u{03D1}"),
2048 |     (b"vartriangleleft", "\u{22B2}"),
2049 |     (b"vartriangleright", "\u{22B3}"),
2050 |     (b"vcy", "\u{0432}"),
2051 |     (b"vdash", "\u{22A2}"),
2052 |     (b"vee", "\u{2228}"),
2053 |     (b"veebar", "\u{22BB}"),
2054 |     (b"veeeq", "\u{225A}"),
2055 |     (b"vellip", "\u{22EE}"),
2056 |     (b"verbar", "\u{007C}"),
2057 |     (b"vert", "\u{007C}"),
2058 |     (b"vfr", "\u{1D533}"),
2059 |     (b"vltri", "\u{22B2}"),
2060 |     (b"vnsub", "\u{2282}"),
2061 |     (b"vnsup", "\u{2283}"),
2062 |     (b"vopf", "\u{1D567}"),
2063 |     (b"vprop", "\u{221D}"),
2064 |     (b"vrtri", "\u{22B3}"),
2065 |     (b"vscr", "\u{1D4CB}"),
2066 |     (b"vsubnE", "\u{2ACB}"),
2067 |     (b"vsubne", "\u{228A}"),
2068 |     (b"vsupnE", "\u{2ACC}"),
2069 |     (b"vsupne", "\u{228B}"),
2070 |     (b"vzigzag", "\u{299A}"),
2071 |     (b"wcirc", "\u{0175}"),
2072 |     (b"wedbar", "\u{2A5F}"),
2073 |     (b"wedge", "\u{2227}"),
2074 |     (b"wedgeq", "\u{2259}"),
2075 |     (b"weierp", "\u{2118}"),
2076 |     (b"wfr", "\u{1D534}"),
2077 |     (b"wopf", "\u{1D568}"),
2078 |     (b"wp", "\u{2118}"),
2079 |     (b"wr", "\u{2240}"),
2080 |     (b"wreath", "\u{2240}"),
2081 |     (b"wscr", "\u{1D4CC}"),
2082 |     (b"xcap", "\u{22C2}"),
2083 |     (b"xcirc", "\u{25EF}"),
2084 |     (b"xcup", "\u{22C3}"),
2085 |     (b"xdtri", "\u{25BD}"),
2086 |     (b"xfr", "\u{1D535}"),
2087 |     (b"xhArr", "\u{27FA}"),
2088 |     (b"xharr", "\u{27F7}"),
2089 |     (b"xi", "\u{03BE}"),
2090 |     (b"xlArr", "\u{27F8}"),
2091 |     (b"xlarr", "\u{27F5}"),
2092 |     (b"xmap", "\u{27FC}"),
2093 |     (b"xnis", "\u{22FB}"),
2094 |     (b"xodot", "\u{2A00}"),
2095 |     (b"xopf", "\u{1D569}"),
2096 |     (b"xoplus", "\u{2A01}"),
2097 |     (b"xotime", "\u{2A02}"),
2098 |     (b"xrArr", "\u{27F9}"),
2099 |     (b"xrarr", "\u{27F6}"),
2100 |     (b"xscr", "\u{1D4CD}"),
2101 |     (b"xsqcup", "\u{2A06}"),
2102 |     (b"xuplus", "\u{2A04}"),
2103 |     (b"xutri", "\u{25B3}"),
2104 |     (b"xvee", "\u{22C1}"),
2105 |     (b"xwedge", "\u{22C0}"),
2106 |     (b"yacute", "\u{00FD}"),
2107 |     (b"yacy", "\u{044F}"),
2108 |     (b"ycirc", "\u{0177}"),
2109 |     (b"ycy", "\u{044B}"),
2110 |     (b"yen", "\u{00A5}"),
2111 |     (b"yfr", "\u{1D536}"),
2112 |     (b"yicy", "\u{0457}"),
2113 |     (b"yopf", "\u{1D56A}"),
2114 |     (b"yscr", "\u{1D4CE}"),
2115 |     (b"yucy", "\u{044E}"),
2116 |     (b"yuml", "\u{00FF}"),
2117 |     (b"zacute", "\u{017A}"),
2118 |     (b"zcaron", "\u{017E}"),
2119 |     (b"zcy", "\u{0437}"),
2120 |     (b"zdot", "\u{017C}"),
2121 |     (b"zeetrf", "\u{2128}"),
2122 |     (b"zeta", "\u{03B6}"),
2123 |     (b"zfr", "\u{1D537}"),
2124 |     (b"zhcy", "\u{0436}"),
2125 |     (b"zigrarr", "\u{21DD}"),
2126 |     (b"zopf", "\u{1D56B}"),
2127 |     (b"zscr", "\u{1D4CF}"),
2128 |     (b"zwj", "\u{200D}"),
2129 |     (b"zwnj", "\u{200C}"),
2130 | ];
2131 | 


--------------------------------------------------------------------------------
/src/decode/mod.rs:
--------------------------------------------------------------------------------
1 | mod element;
2 | mod html_entity;
3 | 
4 | pub use element::*;
5 | pub use html_entity::*;
6 | 


--------------------------------------------------------------------------------
/src/encode/element/encode_impl.rs:
--------------------------------------------------------------------------------
  1 | macro_rules! encode_impl {
  2 |     ($l:expr; $(#[$attr: meta])* $parse_macro:ident; $(#[$encode_attr: meta])* $encode_name: ident; $(#[$encode_to_string_attr: meta])* $encode_to_string_name: ident; $(#[$encode_to_vec_attr: meta])* $encode_to_vec_name: ident; $(#[$encode_to_writer_attr: meta])* $encode_to_writer_name: ident $(;)*) => {
  3 |         $(#[$encode_attr])*
  4 |         ///
  5 |         $(#[$attr])*
  6 |         #[inline]
  7 |         pub fn $encode_name<S: ?Sized + AsRef<str>>(text: &S) -> Cow<str> {
  8 |             let text = text.as_ref();
  9 |             let text_bytes = text.as_bytes();
 10 |             let text_length = text_bytes.len();
 11 | 
 12 |             let mut p = 0;
 13 |             let mut e;
 14 | 
 15 |             let mut step = 0;
 16 | 
 17 |             let (mut v, mut start) = loop {
 18 |                 if p == text_length {
 19 |                     return Cow::from(text);
 20 |                 }
 21 | 
 22 |                 e = text_bytes[p];
 23 | 
 24 |                 $parse_macro!(
 25 |                     e,
 26 |                     step,
 27 |                     {
 28 |                         let mut v = Vec::with_capacity(text_length + 1);
 29 | 
 30 |                         v.extend_from_slice(&text_bytes[..(p - $l)]);
 31 | 
 32 |                         break (v, p - $l);
 33 |                     },
 34 |                     {
 35 |                         let mut v = Vec::with_capacity(text_length + 1);
 36 | 
 37 |                         v.extend_from_slice(&text_bytes[..p]);
 38 | 
 39 |                         break (v, p);
 40 |                     },
 41 |                     {
 42 |                         let mut v = Vec::with_capacity(text_length + 1);
 43 | 
 44 |                         v.extend_from_slice(&text_bytes[..(p - 2)]);
 45 | 
 46 |                         break (v, p - 2);
 47 |                     }
 48 |                 );
 49 | 
 50 |                 p += 1;
 51 |             };
 52 | 
 53 |             v.push(b'\\');
 54 | 
 55 |             p += 1;
 56 | 
 57 |             for e in text_bytes[p..].iter().copied() {
 58 |                 $parse_macro!(
 59 |                     e,
 60 |                     step,
 61 |                     {
 62 |                         v.extend_from_slice(&text_bytes[start..(p - $l)]);
 63 |                         start = p - $l;
 64 |                         v.push(b'\\');
 65 |                     },
 66 |                     {
 67 |                         v.extend_from_slice(&text_bytes[start..p]);
 68 |                         start = p;
 69 |                         v.push(b'\\');
 70 |                     },
 71 |                     {
 72 |                         v.extend_from_slice(&text_bytes[start..(p - 2)]);
 73 |                         start = p - 2;
 74 |                         v.push(b'\\');
 75 |                     }
 76 |                 );
 77 | 
 78 |                 p += 1;
 79 |             }
 80 | 
 81 |             v.extend_from_slice(&text_bytes[start..p]);
 82 | 
 83 |             Cow::from(unsafe { String::from_utf8_unchecked(v) })
 84 |         }
 85 | 
 86 |         $(#[$encode_to_string_attr])*
 87 |         ///
 88 |         $(#[$attr])*
 89 |         #[inline]
 90 |         pub fn $encode_to_string_name<S: AsRef<str>>(text: S, output: &mut String) -> &str {
 91 |             unsafe { from_utf8_unchecked($encode_to_vec_name(text, output.as_mut_vec())) }
 92 |         }
 93 | 
 94 |         $(#[$encode_to_vec_attr])*
 95 |         ///
 96 |         $(#[$attr])*
 97 |         #[inline]
 98 |         pub fn $encode_to_vec_name<S: AsRef<str>>(text: S, output: &mut Vec<u8>) -> &[u8] {
 99 |             let text = text.as_ref();
100 |             let text_bytes = text.as_bytes();
101 |             let text_length = text_bytes.len();
102 | 
103 |             output.reserve(text_length);
104 | 
105 |             let current_length = output.len();
106 | 
107 |             let mut start = 0;
108 |             let mut end = 0;
109 | 
110 |             let mut step = 0;
111 | 
112 |             for e in text_bytes.iter().copied() {
113 |                 $parse_macro!(
114 |                     e,
115 |                     step,
116 |                     {
117 |                         output.extend_from_slice(&text_bytes[start..(end - $l)]);
118 |                         start = end - $l;
119 |                         output.push(b'\\');
120 |                     },
121 |                     {
122 |                         output.extend_from_slice(&text_bytes[start..end]);
123 |                         start = end;
124 |                         output.push(b'\\');
125 |                     },
126 |                     {
127 |                         output.extend_from_slice(&text_bytes[start..(end - 2)]);
128 |                         start = end - 2;
129 |                         output.push(b'\\');
130 |                     }
131 |                 );
132 | 
133 |                 end += 1;
134 |             }
135 | 
136 |             output.extend_from_slice(&text_bytes[start..end]);
137 | 
138 |             &output[current_length..]
139 |         }
140 | 
141 |         #[cfg(feature = "std")]
142 |         $(#[$encode_to_writer_attr])*
143 |         ///
144 |         $(#[$attr])*
145 |         #[inline]
146 |         pub fn $encode_to_writer_name<S: AsRef<str>, W: Write>(text: S, output: &mut W) -> Result<(), io::Error> {
147 |             let text = text.as_ref();
148 |             let text_bytes = text.as_bytes();
149 | 
150 |             let mut start = 0;
151 |             let mut end = 0;
152 | 
153 |             let mut step = 0;
154 | 
155 |             for e in text_bytes.iter().copied() {
156 |                 $parse_macro!(
157 |                     e,
158 |                     step,
159 |                     {
160 |                         output.write_all(&text_bytes[start..(end - $l)])?;
161 |                         start = end - $l;
162 |                         output.write_all(b"\\")?;
163 |                     },
164 |                     {
165 |                         output.write_all(&text_bytes[start..end])?;
166 |                         start = end;
167 |                         output.write_all(b"\\")?;
168 |                     },
169 |                     {
170 |                         output.write_all(&text_bytes[start..(end - 2)])?;
171 |                         start = end - 2;
172 |                         output.write_all(b"\\")?;
173 |                     }
174 |                 );
175 | 
176 |                 end += 1;
177 |             }
178 | 
179 |             output.write_all(&text_bytes[start..end])
180 |         }
181 |     };
182 | }
183 | 


--------------------------------------------------------------------------------
/src/encode/element/mod.rs:
--------------------------------------------------------------------------------
1 | #[macro_use]
2 | mod encode_impl;
3 | 
4 | mod script;
5 | mod style;
6 | 
7 | pub use script::*;
8 | pub use style::*;
9 | 


--------------------------------------------------------------------------------
/src/encode/element/script.rs:
--------------------------------------------------------------------------------
  1 | use alloc::{borrow::Cow, string::String, vec::Vec};
  2 | use core::str::from_utf8_unchecked;
  3 | #[cfg(feature = "std")]
  4 | use std::io::{self, Write};
  5 | 
  6 | macro_rules! parse_script_comment {
  7 |     ($e:expr, $step:ident, $b:block, $bq:block, $bc:block $(, $($addi:expr),+)?) => {
  8 |         match $step {
  9 |             0 => {
 10 |                 match $e {
 11 |                     b'<' => $step = 1,
 12 |                     $(b'\\' => $step = 100,
 13 |                     $(| $addi)+ => $bq,)?
 14 |                     _ => (),
 15 |                 }
 16 |             }
 17 |             1 => {
 18 |                 match $e {
 19 |                     b'/' => $step = 2,
 20 |                     b'!' => $step = 10,
 21 |                     $(b'\\' => $step = 100,
 22 |                     $(| $addi)+ => {
 23 |                         $step = 0;
 24 |                         $bq
 25 |                     },)?
 26 |                     _ => $step = 0,
 27 |                 }
 28 |             }
 29 |             2 => {
 30 |                 match $e {
 31 |                     b's' | b'S' => $step = 3,
 32 |                     $(b'\\' => $step = 100,
 33 |                     $(| $addi)+ => {
 34 |                         $step = 0;
 35 |                         $bq
 36 |                     },)?
 37 |                     _ => $step = 0,
 38 |                 }
 39 |             }
 40 |             3 => {
 41 |                 match $e {
 42 |                     b'c' | b'C' => $step = 4,
 43 |                     $(b'\\' => $step = 100,
 44 |                     $(| $addi)+ => {
 45 |                         $step = 0;
 46 |                         $bq
 47 |                     },)?
 48 |                     _ => $step = 0,
 49 |                 }
 50 |             }
 51 |             4 => {
 52 |                 match $e {
 53 |                     b'r' | b'R' => $step = 5,
 54 |                     $(b'\\' => $step = 100,
 55 |                     $(| $addi)+ => {
 56 |                         $step = 0;
 57 |                         $bq
 58 |                     },)?
 59 |                     _ => $step = 0,
 60 |                 }
 61 |             }
 62 |             5 => {
 63 |                 match $e {
 64 |                     b'i' | b'I' => $step = 6,
 65 |                     $(b'\\' => $step = 100,
 66 |                     $(| $addi)+ => {
 67 |                         $step = 0;
 68 |                         $bq
 69 |                     },)?
 70 |                     _ => $step = 0,
 71 |                 }
 72 |             }
 73 |             6 => {
 74 |                 match $e {
 75 |                     b'p' | b'P' => $step = 7,
 76 |                     $(b'\\' => $step = 100,
 77 |                     $(| $addi)+ => {
 78 |                         $step = 0;
 79 |                         $bq
 80 |                     },)?
 81 |                     _ => $step = 0,
 82 |                 }
 83 |             }
 84 |             7 => {
 85 |                 match $e {
 86 |                     b't' | b'T' => $step = 8,
 87 |                     $(b'\\' => $step = 100,
 88 |                     $(| $addi)+ => {
 89 |                         $step = 0;
 90 |                         $bq
 91 |                     },)?
 92 |                     _ => $step = 0,
 93 |                 }
 94 |             }
 95 |             8 => {
 96 |                 match $e {
 97 |                     b'>' | 9..=13 | 28..=32 => {
 98 |                         $step = 0;
 99 |                         $b
100 |                     },
101 |                     $(b'\\' => $step = 100,
102 |                     $(| $addi)+ => {
103 |                         $step = 0;
104 |                         $bq
105 |                     },)?
106 |                     _ => $step = 0,
107 |                 }
108 |             }
109 |             10 => {
110 |                 match $e {
111 |                     b'-' => $step = 11,
112 |                     $(b'\\' => $step = 100,
113 |                     $(| $addi)+ => {
114 |                         $step = 0;
115 |                         $bq
116 |                     },)?
117 |                     _ => $step = 0,
118 |                 }
119 |             }
120 |             11 => {
121 |                 match $e {
122 |                     b'-' => {
123 |                         $step = 0;
124 |                         $bc
125 |                     },
126 |                     $(b'\\' => $step = 100,
127 |                     $(| $addi)+ => {
128 |                         $step = 0;
129 |                         $bq
130 |                     },)?
131 |                     _ => $step = 0,
132 |                 }
133 |             }
134 |             100 => {
135 |                 match $e {
136 |                     b'<' => $step = 1,
137 |                     _ => $step = 0,
138 |                 }
139 |             }
140 |             _ => unreachable!(),
141 |         }
142 |     };
143 | }
144 | 
145 | macro_rules! parse_script_comment_single_quoted_text {
146 |     ($e:expr, $step:ident, $b:block, $bq:block, $bc:block) => {
147 |         parse_script_comment!($e, $step, $b, $bq, $bc, b'\'');
148 |     };
149 | }
150 | 
151 | macro_rules! parse_script_comment_double_quoted_text {
152 |     ($e:expr, $step:ident, $b:block, $bq:block, $bc:block) => {
153 |         parse_script_comment!($e, $step, $b, $bq, $bc, b'"');
154 |     };
155 | }
156 | 
157 | macro_rules! parse_script_comment_quoted_text {
158 |     ($e:expr, $step:ident, $b:block, $bq:block, $bc:block) => {
159 |         parse_script_comment!($e, $step, $b, $bq, $bc, b'\'', b'"');
160 |     };
161 | }
162 | 
163 | encode_impl! {
164 |     7;
165 |     /// The following substring is escaped:
166 |     ///
167 |     /// * `</script>` => `<\/script>`
168 |     /// * `<!--` => `<\!--`
169 |     parse_script_comment;
170 |     /// Encode text used in the `<script>` element.
171 |     encode_script;
172 |     /// Write text used in the `<script>` element to a mutable `String` reference and return the encoded string slice.
173 |     encode_script_to_string;
174 |     /// Write text used in the `<script>` element to a mutable `Vec<u8>` reference and return the encoded data slice.
175 |     encode_script_to_vec;
176 |     /// Write text used in the `<script>` element to a writer.
177 |     encode_script_to_writer;
178 | }
179 | 
180 | encode_impl! {
181 |     7;
182 |     /// The following substring and character are escaped:
183 |     ///
184 |     /// * `</script>` => `<\/script>`
185 |     /// * `'` => `\'`
186 |     /// * `<!--` => `<\!--`
187 |     parse_script_comment_single_quoted_text;
188 |     /// Encode text used in a single quoted text in the `<script>` element.
189 |     encode_script_single_quoted_text;
190 |     /// Write text used in a single quoted text in the `<script>` element to a mutable `String` reference and return the encoded string slice.
191 |     encode_script_single_quoted_text_to_string;
192 |     /// Write text used in a single quoted text in the `<script>` element to a mutable `Vec<u8>` reference and return the encoded data slice.
193 |     encode_script_single_quoted_text_to_vec;
194 |     /// Write text used in a single quoted text in the `<script>` element to a writer.
195 |     encode_script_single_quoted_text_to_writer;
196 | }
197 | 
198 | encode_impl! {
199 |     7;
200 |     /// The following substring and character are escaped:
201 |     ///
202 |     /// * `</script>` => `<\/script>`
203 |     /// * `"` => `\"`
204 |     /// * `<!--` => `<\!--`
205 |     parse_script_comment_double_quoted_text;
206 |     /// Encode text used in a double quoted text in the `<script>` element.
207 |     encode_script_double_quoted_text;
208 |     /// Write text used in a double quoted text in the `<script>` element to a mutable `String` reference and return the encoded string slice.
209 |     encode_script_double_quoted_text_to_string;
210 |     /// Write text used in a double quoted text in the `<script>` element to a mutable `Vec<u8>` reference and return the encoded data slice.
211 |     encode_script_double_quoted_text_to_vec;
212 |     /// Write text used in a double quoted text in the `<script>` element to a writer.
213 |     encode_script_double_quoted_text_to_writer;
214 | }
215 | 
216 | encode_impl! {
217 |     7;
218 |     /// The following substring and characters are escaped:
219 |     ///
220 |     /// * `</script>` => `<\/script>`
221 |     /// * `"` => `\"`
222 |     /// * `'` => `\'`
223 |     /// * `<!--` => `<\!--`
224 |     parse_script_comment_quoted_text;
225 |     /// Encode text used in a quoted text in the `<script>` element.
226 |     encode_script_quoted_text;
227 |     /// Write text used in a quoted text in the `<script>` element to a mutable `String` reference and return the encoded string slice.
228 |     encode_script_quoted_text_to_string;
229 |     /// Write text used in a quoted text in the `<script>` element to a mutable `Vec<u8>` reference and return the encoded data slice.
230 |     encode_script_quoted_text_to_vec;
231 |     /// Write text used in a quoted text in the `<script>` element to a writer.
232 |     encode_script_quoted_text_to_writer;
233 | }
234 | 


--------------------------------------------------------------------------------
/src/encode/element/style.rs:
--------------------------------------------------------------------------------
  1 | use alloc::{borrow::Cow, string::String, vec::Vec};
  2 | use core::str::from_utf8_unchecked;
  3 | #[cfg(feature = "std")]
  4 | use std::io::{self, Write};
  5 | 
  6 | macro_rules! parse_style_comment {
  7 |     ($e:expr, $step:ident, $b:block, $bq:block, $bc:block $(, $($addi:expr),+)?) => {
  8 |         match $step {
  9 |             0 => {
 10 |                 match $e {
 11 |                     b'<' => $step = 1,
 12 |                     $(b'\\' => $step = 100,
 13 |                     $(| $addi)+ => $bq,)?
 14 |                     _ => (),
 15 |                 }
 16 |             }
 17 |             1 => {
 18 |                 match $e {
 19 |                     b'/' => $step = 2,
 20 |                     b'!' => $step = 10,
 21 |                     $(b'\\' => $step = 100,
 22 |                     $(| $addi)+ => {
 23 |                         $step = 0;
 24 |                         $bq
 25 |                     },)?
 26 |                     _ => $step = 0,
 27 |                 }
 28 |             }
 29 |             2 => {
 30 |                 match $e {
 31 |                     b's' | b'S' => $step = 3,
 32 |                     $(b'\\' => $step = 100,
 33 |                     $(| $addi)+ => {
 34 |                         $step = 0;
 35 |                         $bq
 36 |                     },)?
 37 |                     _ => $step = 0,
 38 |                 }
 39 |             }
 40 |             3 => {
 41 |                 match $e {
 42 |                     b't' | b'T' => $step = 4,
 43 |                     $(b'\\' => $step = 100,
 44 |                     $(| $addi)+ => {
 45 |                         $step = 0;
 46 |                         $bq
 47 |                     },)?
 48 |                     _ => $step = 0,
 49 |                 }
 50 |             }
 51 |             4 => {
 52 |                 match $e {
 53 |                     b'y' | b'Y' => $step = 5,
 54 |                     $(b'\\' => $step = 100,
 55 |                     $(| $addi)+ => {
 56 |                         $step = 0;
 57 |                         $bq
 58 |                     },)?
 59 |                     _ => $step = 0,
 60 |                 }
 61 |             }
 62 |             5 => {
 63 |                 match $e {
 64 |                     b'l' | b'L' => $step = 6,
 65 |                     $(b'\\' => $step = 100,
 66 |                     $(| $addi)+ => {
 67 |                         $step = 0;
 68 |                         $bq
 69 |                     },)?
 70 |                     _ => $step = 0,
 71 |                 }
 72 |             }
 73 |             6 => {
 74 |                 match $e {
 75 |                     b'e' | b'E' => $step = 7,
 76 |                     $(b'\\' => $step = 100,
 77 |                     $(| $addi)+ => {
 78 |                         $step = 0;
 79 |                         $bq
 80 |                     },)?
 81 |                     _ => $step = 0,
 82 |                 }
 83 |             }
 84 |             7 => {
 85 |                 match $e {
 86 |                     b'>' | 9..=13 | 28..=32 => {
 87 |                         $step = 0;
 88 |                         $b
 89 |                     },
 90 |                     $(b'\\' => $step = 100,
 91 |                     $(| $addi)+ => {
 92 |                         $step = 0;
 93 |                         $bq
 94 |                     },)?
 95 |                     _ => $step = 0,
 96 |                 }
 97 |             }
 98 |             10 => {
 99 |                 match $e {
100 |                     b'-' => $step = 11,
101 |                     $(b'\\' => $step = 100,
102 |                     $(| $addi)+ => {
103 |                         $step = 0;
104 |                         $bq
105 |                     },)?
106 |                     _ => $step = 0,
107 |                 }
108 |             }
109 |             11 => {
110 |                 match $e {
111 |                     b'-' => {
112 |                         $step = 0;
113 |                         $bc
114 |                     },
115 |                     $(b'\\' => $step = 100,
116 |                     $(| $addi)+ => {
117 |                         $step = 0;
118 |                         $bq
119 |                     },)?
120 |                     _ => $step = 0,
121 |                 }
122 |             }
123 |             100 => {
124 |                 match $e {
125 |                     b'<' => $step = 1,
126 |                     _ => $step = 0,
127 |                 }
128 |             }
129 |             _ => unreachable!(),
130 |         }
131 |     };
132 | }
133 | 
134 | macro_rules! parse_style_comment_single_quoted_text {
135 |     ($e:expr, $step:ident, $b:block, $bq:block, $bc:block) => {
136 |         parse_style_comment!($e, $step, $b, $bq, $bc, b'\'');
137 |     };
138 | }
139 | 
140 | macro_rules! parse_style_comment_double_quoted_text {
141 |     ($e:expr, $step:ident, $b:block, $bq:block, $bc:block) => {
142 |         parse_style_comment!($e, $step, $b, $bq, $bc, b'"');
143 |     };
144 | }
145 | 
146 | macro_rules! parse_style_comment_quoted_text {
147 |     ($e:expr, $step:ident, $b:block, $bq:block, $bc:block) => {
148 |         parse_style_comment!($e, $step, $b, $bq, $bc, b'\'', b'"');
149 |     };
150 | }
151 | 
152 | encode_impl! {
153 |     6;
154 |     /// The following substring is escaped:
155 |     ///
156 |     /// * `</style>` => `<\/style>`
157 |     /// * `<!--` => `<\!--`
158 |     parse_style_comment;
159 |     /// Encode text used in the `<style>` element.
160 |     encode_style;
161 |     /// Write text used in the `<style>` element to a mutable `String` reference and return the encoded string slice.
162 |     encode_style_to_string;
163 |     /// Write text used in the `<style>` element to a mutable `Vec<u8>` reference and return the encoded data slice.
164 |     encode_style_to_vec;
165 |     /// Write text used in the `<style>` element to a writer.
166 |     encode_style_to_writer;
167 | }
168 | 
169 | encode_impl! {
170 |     6;
171 |     /// The following substring and character are escaped:
172 |     ///
173 |     /// * `</style>` => `<\/style>`
174 |     /// * `'` => `\'`
175 |     /// * `<!--` => `<\!--`
176 |     parse_style_comment_single_quoted_text;
177 |     /// Encode text used in a single quoted text in the `<style>` element.
178 |     encode_style_single_quoted_text;
179 |     /// Write text used in a single quoted text in the `<style>` element to a mutable `String` reference and return the encoded string slice.
180 |     encode_style_single_quoted_text_to_string;
181 |     /// Write text used in a single quoted text in the `<style>` element to a mutable `Vec<u8>` reference and return the encoded data slice.
182 |     encode_style_single_quoted_text_to_vec;
183 |     /// Write text used in a single quoted text in the `<style>` element to a writer.
184 |     encode_style_single_quoted_text_to_writer;
185 | }
186 | 
187 | encode_impl! {
188 |     6;
189 |     /// The following substring and character are escaped:
190 |     ///
191 |     /// * `</style>` => `<\/style>`
192 |     /// * `"` => `\"`
193 |     /// * `<!--` => `<\!--`
194 |     parse_style_comment_double_quoted_text;
195 |     /// Encode text used in a double quoted text in the `<style>` element.
196 |     encode_style_double_quoted_text;
197 |     /// Write text used in a double quoted text in the `<style>` element to a mutable `String` reference and return the encoded string slice.
198 |     encode_style_double_quoted_text_to_string;
199 |     /// Write text used in a double quoted text in the `<style>` element to a mutable `Vec<u8>` reference and return the encoded data slice.
200 |     encode_style_double_quoted_text_to_vec;
201 |     /// Write text used in a double quoted text in the `<style>` element to a writer.
202 |     encode_style_double_quoted_text_to_writer;
203 | }
204 | 
205 | encode_impl! {
206 |     6;
207 |     /// The following substring and characters are escaped:
208 |     ///
209 |     /// * `</style>` => `<\/style>`
210 |     /// * `"` => `\"`
211 |     /// * `'` => `\'`
212 |     /// * `<!--` => `<\!--`
213 |     parse_style_comment_quoted_text;
214 |     /// Encode text used in a quoted text in the `<style>` element.
215 |     encode_style_quoted_text;
216 |     /// Write text used in a quoted text in the `<style>` element to a mutable `String` reference and return the encoded string slice.
217 |     encode_style_quoted_text_to_string;
218 |     /// Write text used in a quoted text in the `<style>` element to a mutable `Vec<u8>` reference and return the encoded data slice.
219 |     encode_style_quoted_text_to_vec;
220 |     /// Write text used in a quoted text in the `<style>` element to a writer.
221 |     encode_style_quoted_text_to_writer;
222 | }
223 | 


--------------------------------------------------------------------------------
/src/encode/html_entity/mod.rs:
--------------------------------------------------------------------------------
  1 | mod unquoted_attribute;
  2 | 
  3 | use alloc::{borrow::Cow, string::String, vec::Vec};
  4 | use core::str::from_utf8_unchecked;
  5 | #[cfg(feature = "std")]
  6 | use std::io::{self, Write};
  7 | 
  8 | pub use unquoted_attribute::*;
  9 | 
 10 | macro_rules! escape_impl {
 11 |     (@inner [$dollar:tt] $name:ident; $($l:expr => $r:expr),+ $(,)*) => {
 12 |         macro_rules! $name {
 13 |             ($dollar e:expr) => {
 14 |                 match $dollar e {
 15 |                     $($l => break $r,)+
 16 |                     _ => (),
 17 |                 }
 18 |             };
 19 |             (vec $dollar e:expr, $dollar v:ident, $dollar b:ident, $dollar start:ident, $dollar end:ident) => {
 20 |                 match $dollar e {
 21 |                     $($l => {
 22 |                         $dollar v.extend_from_slice(&$dollar b[$dollar start..$dollar end]);
 23 |                         $dollar start = $dollar end + 1;
 24 |                         $dollar v.extend_from_slice($r);
 25 |                     })+
 26 |                     _ => (),
 27 |                 }
 28 | 
 29 |                 $dollar end += 1;
 30 |             };
 31 |             (writer $dollar e:expr, $dollar w:ident, $dollar b:ident, $dollar start:ident, $dollar end:ident) => {
 32 |                 match $dollar e {
 33 |                     $($l => {
 34 |                         $dollar w.write_all(&$dollar b[$dollar start..$dollar end])?;
 35 |                         $dollar start = $dollar end + 1;
 36 |                         $dollar w.write_all($r)?;
 37 |                     })+
 38 |                     _ => (),
 39 |                 }
 40 | 
 41 |                 $dollar end += 1;
 42 |             };
 43 |         }
 44 |     };
 45 |     ($name:ident; $($l:expr => $r:expr),+ $(,)*) => {
 46 |         escape_impl! {
 47 |             @inner [$]
 48 |             $name;
 49 |             $($l => $r.as_ref(),)*
 50 |         }
 51 |     };
 52 | }
 53 | 
 54 | escape_impl! {
 55 |     escape_text_minimal;
 56 |     b'&' => b"&amp;",
 57 |     b'<' => b"&lt;",
 58 | }
 59 | 
 60 | escape_impl! {
 61 |     escape_text;
 62 |     b'&' => b"&amp;",
 63 |     b'<' => b"&lt;",
 64 |     b'>' => b"&gt;",
 65 | }
 66 | 
 67 | escape_impl! {
 68 |     escape_double_quote;
 69 |     b'&' => b"&amp;",
 70 |     b'<' => b"&lt;",
 71 |     b'>' => b"&gt;",
 72 |     b'"' => b"&quot;",
 73 | }
 74 | 
 75 | escape_impl! {
 76 |     escape_single_quote;
 77 |     b'&' => b"&amp;",
 78 |     b'<' => b"&lt;",
 79 |     b'>' => b"&gt;",
 80 |     b'\'' => b"&#x27;",
 81 | }
 82 | 
 83 | escape_impl! {
 84 |     escape_quote;
 85 |     b'&' => b"&amp;",
 86 |     b'<' => b"&lt;",
 87 |     b'>' => b"&gt;",
 88 |     b'"' => b"&quot;",
 89 |     b'\'' => b"&#x27;",
 90 | }
 91 | 
 92 | escape_impl! {
 93 |     escape_safe;
 94 |     b'&' => b"&amp;",
 95 |     b'<' => b"&lt;",
 96 |     b'>' => b"&gt;",
 97 |     b'"' => b"&quot;",
 98 |     b'\'' => b"&#x27;",
 99 |     b'/' => b"&#x2F;",
100 | }
101 | 
102 | macro_rules! encode_impl {
103 |     ($(#[$attr: meta])* $escape_macro:ident; $(#[$encode_attr: meta])* $encode_name: ident; $(#[$encode_to_string_attr: meta])* $encode_to_string_name: ident; $(#[$encode_to_vec_attr: meta])* $encode_to_vec_name: ident; $(#[$encode_to_writer_attr: meta])* $encode_to_writer_name: ident $(;)*) => {
104 |         $(#[$encode_attr])*
105 |         ///
106 |         $(#[$attr])*
107 |         #[inline]
108 |         pub fn $encode_name<S: ?Sized + AsRef<str>>(text: &S) -> Cow<str> {
109 |             let text = text.as_ref();
110 |             let text_bytes = text.as_bytes();
111 |             let text_length = text_bytes.len();
112 | 
113 |             let mut p = 0;
114 |             let mut e;
115 | 
116 |             let first = loop {
117 |                 if p == text_length {
118 |                     return Cow::from(text);
119 |                 }
120 | 
121 |                 e = text_bytes[p];
122 | 
123 |                 $escape_macro!(e);
124 | 
125 |                 p += 1;
126 |             };
127 | 
128 |             let mut v = Vec::with_capacity(text_length + 5);
129 | 
130 |             v.extend_from_slice(&text_bytes[..p]);
131 |             v.extend_from_slice(first);
132 | 
133 |             $encode_to_vec_name(unsafe { from_utf8_unchecked(&text_bytes[(p + 1)..]) }, &mut v);
134 | 
135 |             Cow::from(unsafe { String::from_utf8_unchecked(v) })
136 |         }
137 | 
138 |         $(#[$encode_to_string_attr])*
139 |         ///
140 |         $(#[$attr])*
141 |         #[inline]
142 |         pub fn $encode_to_string_name<S: AsRef<str>>(text: S, output: &mut String) -> &str {
143 |             unsafe { from_utf8_unchecked($encode_to_vec_name(text, output.as_mut_vec())) }
144 |         }
145 | 
146 |         $(#[$encode_to_vec_attr])*
147 |         ///
148 |         $(#[$attr])*
149 |         #[inline]
150 |         pub fn $encode_to_vec_name<S: AsRef<str>>(text: S, output: &mut Vec<u8>) -> &[u8] {
151 |             let text = text.as_ref();
152 |             let text_bytes = text.as_bytes();
153 |             let text_length = text_bytes.len();
154 | 
155 |             output.reserve(text_length);
156 | 
157 |             let current_length = output.len();
158 | 
159 |             let mut start = 0;
160 |             let mut end = 0;
161 | 
162 |             for e in text_bytes.iter().copied() {
163 |                 $escape_macro!(vec e, output, text_bytes, start, end);
164 |             }
165 | 
166 |             output.extend_from_slice(&text_bytes[start..end]);
167 | 
168 |             &output[current_length..]
169 |         }
170 | 
171 |         #[cfg(feature = "std")]
172 |         $(#[$encode_to_writer_attr])*
173 |         ///
174 |         $(#[$attr])*
175 |         #[inline]
176 |         pub fn $encode_to_writer_name<S: AsRef<str>, W: Write>(text: S, output: &mut W) -> Result<(), io::Error> {
177 |             let text = text.as_ref();
178 |             let text_bytes = text.as_bytes();
179 | 
180 |             let mut start = 0;
181 |             let mut end = 0;
182 | 
183 |             for e in text_bytes.iter().copied() {
184 |                 $escape_macro!(writer e, output, text_bytes, start, end);
185 |             }
186 | 
187 |             output.write_all(&text_bytes[start..end])
188 |         }
189 |     };
190 | }
191 | 
192 | encode_impl! {
193 |     /// The following characters are escaped:
194 |     ///
195 |     /// * `&` => `&amp;`
196 |     /// * `<` => `&lt;`
197 |     escape_text_minimal;
198 |     /// Encode text used as regular HTML text.
199 |     encode_text_minimal;
200 |     /// Write text used as regular HTML text to a mutable `String` reference and return the encoded string slice.
201 |     encode_text_minimal_to_string;
202 |     /// Write text used as regular HTML text to a mutable `Vec<u8>` reference and return the encoded data slice.
203 |     encode_text_minimal_to_vec;
204 |     /// Write text used as regular HTML text to a writer.
205 |     encode_text_minimal_to_writer;
206 | }
207 | 
208 | encode_impl! {
209 |     /// The following characters are escaped:
210 |     ///
211 |     /// * `&` => `&amp;`
212 |     /// * `<` => `&lt;`
213 |     /// * `>` => `&gt;`
214 |     escape_text;
215 |     /// Encode text used as regular HTML text.
216 |     encode_text;
217 |     /// Write text used as regular HTML text to a mutable `String` reference and return the encoded string slice.
218 |     encode_text_to_string;
219 |     /// Write text used as regular HTML text to a mutable `Vec<u8>` reference and return the encoded data slice.
220 |     encode_text_to_vec;
221 |     /// Write text used as regular HTML text to a writer.
222 |     encode_text_to_writer;
223 | }
224 | 
225 | encode_impl! {
226 |     /// The following characters are escaped:
227 |     ///
228 |     /// * `&` => `&amp;`
229 |     /// * `<` => `&lt;`
230 |     /// * `>` => `&gt;`
231 |     /// * `"` => `&quot;`
232 |     escape_double_quote;
233 |     /// Encode text used in a double-quoted attribute.
234 |     encode_double_quoted_attribute;
235 |     /// Write text used in a double-quoted attribute to a mutable `String` reference and return the encoded string slice.
236 |     encode_double_quoted_attribute_to_string;
237 |     /// Write text used in a double-quoted attribute to a mutable `Vec<u8>` reference and return the encoded data slice.
238 |     encode_double_quoted_attribute_to_vec;
239 |     /// Write text used in a double-quoted attribute to a writer.
240 |     encode_double_quoted_attribute_to_writer;
241 | }
242 | 
243 | encode_impl! {
244 |     /// The following characters are escaped:
245 |     ///
246 |     /// * `&` => `&amp;`
247 |     /// * `<` => `&lt;`
248 |     /// * `>` => `&gt;`
249 |     /// * `'` => `&#x27;`
250 |     escape_single_quote;
251 |     /// Encode text used in a single-quoted attribute.
252 |     encode_single_quoted_attribute;
253 |     /// Write text used in a single-quoted attribute to a mutable `String` reference and return the encoded string slice.
254 |     encode_single_quoted_attribute_to_string;
255 |     /// Write text used in a single-quoted attribute to a mutable `Vec<u8>` reference and return the encoded data slice.
256 |     encode_single_quoted_attribute_to_vec;
257 |     /// Write text used in a single-quoted attribute to a writer.
258 |     encode_single_quoted_attribute_to_writer;
259 | }
260 | 
261 | encode_impl! {
262 |     /// The following characters (HTML reserved characters)  are escaped:
263 |     ///
264 |     /// * `&` => `&amp;`
265 |     /// * `<` => `&lt;`
266 |     /// * `>` => `&gt;`
267 |     /// * `"` => `&quot;`
268 |     /// * `'` => `&#x27;`
269 |     escape_quote;
270 |     /// Encode text used in a quoted attribute.
271 |     encode_quoted_attribute;
272 |     /// Write text used in a quoted attribute to a mutable `String` reference and return the encoded string slice.
273 |     encode_quoted_attribute_to_string;
274 |     /// Write text used in a quoted attribute to a mutable `Vec<u8>` reference and return the encoded data slice.
275 |     encode_quoted_attribute_to_vec;
276 |     /// Write text used in a quoted attribute to a writer.
277 |     encode_quoted_attribute_to_writer;
278 | }
279 | 
280 | encode_impl! {
281 |     /// The following characters are escaped:
282 |     ///
283 |     /// * `&` => `&amp;`
284 |     /// * `<` => `&lt;`
285 |     /// * `>` => `&gt;`
286 |     /// * `"` => `&quot;`
287 |     /// * `'` => `&#x27;`
288 |     /// * `/` => `&#x2F;`
289 |     escape_safe;
290 |     /// Encode text to prevent special characters functioning.
291 |     encode_safe;
292 |     /// Encode text to prevent special characters functioning and write it to a mutable `String` reference and return the encoded string slice.
293 |     encode_safe_to_string;
294 |     /// Encode text to prevent special characters functioning and write it to a mutable `Vec<u8>` reference and return the encoded data slice.
295 |     encode_safe_to_vec;
296 |     /// Encode text to prevent special characters functioning and write it to a writer.
297 |     encode_safe_to_writer;
298 | }
299 | 


--------------------------------------------------------------------------------
/src/encode/html_entity/unquoted_attribute.rs:
--------------------------------------------------------------------------------
  1 | use alloc::{borrow::Cow, string::String, vec::Vec};
  2 | use core::str::from_utf8_unchecked;
  3 | #[cfg(feature = "std")]
  4 | use std::io::{self, Write};
  5 | 
  6 | use crate::functions::*;
  7 | 
  8 | /// Encode text used in an unquoted attribute. Except for alphanumeric characters, escape all characters which are less than 128.
  9 | ///
 10 | /// The following characters are escaped to named entities:
 11 | ///
 12 | /// * `&` => `&amp;`
 13 | /// * `<` => `&lt;`
 14 | /// * `>` => `&gt;`
 15 | /// * `"` => `&quot;`
 16 | ///
 17 | /// Other non-alphanumeric characters are escaped to `&#xHH;`.
 18 | pub fn encode_unquoted_attribute<S: ?Sized + AsRef<str>>(text: &S) -> Cow<str> {
 19 |     let text = text.as_ref();
 20 |     let text_bytes = text.as_bytes();
 21 | 
 22 |     let text_length = text_bytes.len();
 23 | 
 24 |     let mut p = 0;
 25 |     let mut e;
 26 | 
 27 |     loop {
 28 |         if p == text_length {
 29 |             return Cow::from(text);
 30 |         }
 31 | 
 32 |         e = text_bytes[p];
 33 | 
 34 |         if utf8_width::is_width_1(e) && !e.is_ascii_alphanumeric() {
 35 |             break;
 36 |         }
 37 | 
 38 |         p += 1;
 39 |     }
 40 | 
 41 |     let mut v = Vec::with_capacity(text_length);
 42 | 
 43 |     v.extend_from_slice(&text_bytes[..p]);
 44 | 
 45 |     write_html_entity_to_vec(e, &mut v);
 46 | 
 47 |     encode_unquoted_attribute_to_vec(
 48 |         unsafe { from_utf8_unchecked(&text_bytes[(p + 1)..]) },
 49 |         &mut v,
 50 |     );
 51 | 
 52 |     Cow::from(unsafe { String::from_utf8_unchecked(v) })
 53 | }
 54 | 
 55 | /// Write text used in an unquoted attribute to a mutable `String` reference and return the encoded string slice. Except for alphanumeric characters, escape all characters which are less than 128.
 56 | ///
 57 | /// The following characters are escaped to named entities:
 58 | ///
 59 | /// * `&` => `&amp;`
 60 | /// * `<` => `&lt;`
 61 | /// * `>` => `&gt;`
 62 | /// * `"` => `&quot;`
 63 | ///
 64 | /// Other non-alphanumeric characters are escaped to `&#xHH;`.
 65 | #[inline]
 66 | pub fn encode_unquoted_attribute_to_string<S: AsRef<str>>(text: S, output: &mut String) -> &str {
 67 |     unsafe { from_utf8_unchecked(encode_unquoted_attribute_to_vec(text, output.as_mut_vec())) }
 68 | }
 69 | 
 70 | /// Write text used in an unquoted attribute to a mutable `Vec<u8>` reference and return the encoded data slice. Except for alphanumeric characters, escape all characters which are less than 128.
 71 | ///
 72 | /// The following characters are escaped to named entities:
 73 | ///
 74 | /// * `&` => `&amp;`
 75 | /// * `<` => `&lt;`
 76 | /// * `>` => `&gt;`
 77 | /// * `"` => `&quot;`
 78 | ///
 79 | /// Other non-alphanumeric characters are escaped to `&#xHH;`.
 80 | pub fn encode_unquoted_attribute_to_vec<S: AsRef<str>>(text: S, output: &mut Vec<u8>) -> &[u8] {
 81 |     let text = text.as_ref();
 82 |     let text_bytes = text.as_bytes();
 83 |     let text_length = text_bytes.len();
 84 | 
 85 |     output.reserve(text_length);
 86 | 
 87 |     let current_length = output.len();
 88 | 
 89 |     let mut p = 0;
 90 |     let mut e;
 91 | 
 92 |     let mut start = 0;
 93 | 
 94 |     while p < text_length {
 95 |         e = text_bytes[p];
 96 | 
 97 |         if utf8_width::is_width_1(e) && !e.is_ascii_alphanumeric() {
 98 |             output.extend_from_slice(&text_bytes[start..p]);
 99 |             start = p + 1;
100 |             write_html_entity_to_vec(e, output);
101 |         }
102 | 
103 |         p += 1;
104 |     }
105 | 
106 |     output.extend_from_slice(&text_bytes[start..p]);
107 | 
108 |     &output[current_length..]
109 | }
110 | 
111 | #[cfg(feature = "std")]
112 | /// Write text used in an unquoted attribute to a writer. Except for alphanumeric characters, escape all characters which are less than 128.
113 | ///
114 | /// The following characters are escaped to named entities:
115 | ///
116 | /// * `&` => `&amp;`
117 | /// * `<` => `&lt;`
118 | /// * `>` => `&gt;`
119 | /// * `"` => `&quot;`
120 | ///
121 | /// Other non-alphanumeric characters are escaped to `&#xHH;`.
122 | pub fn encode_unquoted_attribute_to_writer<S: AsRef<str>, W: Write>(
123 |     text: S,
124 |     output: &mut W,
125 | ) -> Result<(), io::Error> {
126 |     let text = text.as_ref();
127 |     let text_bytes = text.as_bytes();
128 |     let text_length = text_bytes.len();
129 | 
130 |     let mut p = 0;
131 |     let mut e;
132 | 
133 |     let mut start = 0;
134 | 
135 |     while p < text_length {
136 |         e = text_bytes[p];
137 | 
138 |         if utf8_width::is_width_1(e) && !e.is_ascii_alphanumeric() {
139 |             output.write_all(&text_bytes[start..p])?;
140 |             start = p + 1;
141 |             write_html_entity_to_writer(e, output)?;
142 |         }
143 | 
144 |         p += 1;
145 |     }
146 | 
147 |     output.write_all(&text_bytes[start..p])
148 | }
149 | 


--------------------------------------------------------------------------------
/src/encode/mod.rs:
--------------------------------------------------------------------------------
1 | mod element;
2 | mod html_entity;
3 | 
4 | pub use element::*;
5 | pub use html_entity::*;
6 | 


--------------------------------------------------------------------------------
/src/functions.rs:
--------------------------------------------------------------------------------
 1 | use alloc::vec::Vec;
 2 | #[cfg(feature = "std")]
 3 | use std::io::{self, Write};
 4 | 
 5 | #[inline]
 6 | pub(crate) fn write_hex_to_vec(e: u8, output: &mut Vec<u8>) {
 7 |     output.reserve(6);
 8 | 
 9 |     let length = output.len();
10 | 
11 |     unsafe {
12 |         output.set_len(length + 6);
13 |     }
14 | 
15 |     let output = &mut output[length..];
16 | 
17 |     output[0] = b'&';
18 |     output[1] = b'#';
19 |     output[2] = b'x';
20 |     output[5] = b';';
21 | 
22 |     let he = e >> 4;
23 |     let le = e & 0xF;
24 | 
25 |     output[3] = if he >= 10 { b'A' - 10 + he } else { b'0' + he };
26 | 
27 |     output[4] = if le >= 10 { b'A' - 10 + le } else { b'0' + le };
28 | }
29 | 
30 | #[cfg(feature = "std")]
31 | #[inline]
32 | pub(crate) fn write_hex_to_writer<W: Write>(e: u8, output: &mut W) -> Result<(), io::Error> {
33 |     output.write_fmt(format_args!("&#x{e:02X};"))
34 | }
35 | 
36 | #[inline]
37 | pub(crate) fn write_html_entity_to_vec(e: u8, output: &mut Vec<u8>) {
38 |     match e {
39 |         b'&' => output.extend_from_slice(b"&amp;"),
40 |         b'<' => output.extend_from_slice(b"&lt;"),
41 |         b'>' => output.extend_from_slice(b"&gt;"),
42 |         b'"' => output.extend_from_slice(b"&quot;"),
43 |         _ => write_hex_to_vec(e, output),
44 |     }
45 | }
46 | 
47 | #[cfg(feature = "std")]
48 | #[inline]
49 | pub(crate) fn write_html_entity_to_writer<W: Write>(
50 |     e: u8,
51 |     output: &mut W,
52 | ) -> Result<(), io::Error> {
53 |     match e {
54 |         b'&' => output.write_all(b"&amp;"),
55 |         b'<' => output.write_all(b"&lt;"),
56 |         b'>' => output.write_all(b"&gt;"),
57 |         b'"' => output.write_all(b"&quot;"),
58 |         _ => write_hex_to_writer(e, output),
59 |     }
60 | }
61 | 
62 | #[inline]
63 | pub(crate) fn write_char_to_vec(c: char, output: &mut Vec<u8>) {
64 |     let width = c.len_utf8();
65 | 
66 |     output.reserve(width);
67 | 
68 |     let current_length = output.len();
69 | 
70 |     unsafe {
71 |         output.set_len(current_length + width);
72 |     }
73 | 
74 |     c.encode_utf8(&mut output[current_length..]);
75 | }
76 | 
77 | #[cfg(feature = "std")]
78 | #[inline]
79 | pub(crate) fn write_char_to_writer<W: Write>(c: char, output: &mut W) -> Result<(), io::Error> {
80 |     let mut buffer = [0u8; 4];
81 |     let length = c.encode_utf8(&mut buffer).len();
82 | 
83 |     output.write_all(&buffer[..length])
84 | }
85 | 


--------------------------------------------------------------------------------
/src/lib.rs:
--------------------------------------------------------------------------------
 1 | /*!
 2 | # HTML Escape
 3 | 
 4 | This library is for encoding/escaping special characters in HTML and decoding/unescaping HTML entities as well.
 5 | 
 6 | ## Usage
 7 | 
 8 | ### Encoding
 9 | 
10 | This crate provides some `encode_*` functions to encode HTML text in different situations.
11 | 
12 | For example, to put a text between a start tag `<foo>` and an end tag `</foo>`, use the `encode_text` function to escape every `&`, `<`, and `>` in the text.
13 | 
14 | ```rust
15 | assert_eq!("a &gt; b &amp;&amp; a &lt; c", html_escape::encode_text("a > b && a < c"));
16 | ```
17 | 
18 | The functions suffixed with `_to_writer`, `_to_vec` or `_to_string` are useful to generate HTML.
19 | 
20 | ```rust
21 | let mut html = String::from("<input value=");
22 | assert_eq!("Hello&#x20;world&#x21;", html_escape::encode_unquoted_attribute_to_string("Hello world!", &mut html));
23 | html.push_str(" placeholder=\"");
24 | assert_eq!("The default value is &quot;Hello world!&quot;.", html_escape::encode_double_quoted_attribute_to_string("The default value is \"Hello world!\".", &mut html));
25 | html.push_str("\"/><script>alert('");
26 | assert_eq!(r"<script>\'s end tag is <\/script>", html_escape::encode_script_single_quoted_text_to_string("<script>'s end tag is </script>", &mut html));
27 | html.push_str("');</script>");
28 | 
29 | assert_eq!("<input value=Hello&#x20;world&#x21; placeholder=\"The default value is &quot;Hello world!&quot;.\"/><script>alert(\'<script>\\\'s end tag is <\\/script>\');</script>", html);
30 | ```
31 | 
32 | ### Decoding
33 | 
34 | ```rust
35 | assert_eq!("Hello world!", html_escape::decode_html_entities("Hello&#x20;world&#x21;"));
36 | ```
37 | 
38 | ```rust
39 | assert_eq!("alert('<script></script>');", html_escape::decode_script(r"alert('<script><\/script>');"));
40 | ```
41 | 
42 | ## No Std
43 | 
44 | Disable the default features to compile this crate without std.
45 | 
46 | ```toml
47 | [dependencies.html-escape]
48 | version = "*"
49 | default-features = false
50 | ```
51 | 
52 | ## Benchmark
53 | 
54 | ```bash
55 | cargo bench
56 | ```
57 | */
58 | 
59 | #![cfg_attr(not(feature = "std"), no_std)]
60 | 
61 | extern crate alloc;
62 | 
63 | mod decode;
64 | mod encode;
65 | mod functions;
66 | 
67 | pub use decode::*;
68 | pub use encode::*;
69 | 


--------------------------------------------------------------------------------
/tests/element.rs:
--------------------------------------------------------------------------------
  1 | const SCRIPT_CASES: [(&str, &str); 7] = [
  2 |     ("", ""),
  3 |     ("哈囉，中文！", "哈囉，中文！"),
  4 |     (r"alert('<script><\/scrIpt >');", "alert('<script></scrIpt >');"),
  5 |     (
  6 |         r"alert('<script><\/script>');alert('<script><\/script >');",
  7 |         "alert('<script></script>');alert('<script></script >');",
  8 |     ),
  9 |     (r"alert('<\!--');", "alert('<!--');"),
 10 |     (r"alert('<\!-- -->');alert('<\!--');", "alert('<!-- -->');alert('<!--');"),
 11 |     (r"alert('<script><\!--<\/script>');", "alert('<script><!--</script>');"),
 12 | ];
 13 | 
 14 | #[test]
 15 | fn encode_script() {
 16 |     for (expect, text) in SCRIPT_CASES.iter().copied() {
 17 |         assert_eq!(expect, html_escape::encode_script(text));
 18 |     }
 19 | }
 20 | 
 21 | #[test]
 22 | fn encode_script_to_string() {
 23 |     for (expect, text) in SCRIPT_CASES.iter().copied() {
 24 |         assert_eq!(expect, html_escape::encode_script_to_string(text, &mut String::new()));
 25 |     }
 26 | }
 27 | 
 28 | #[cfg(feature = "std")]
 29 | #[test]
 30 | fn encode_script_to_writer() {
 31 |     for (expect, text) in SCRIPT_CASES.iter().copied() {
 32 |         let mut v = Vec::new();
 33 |         html_escape::encode_script_to_writer(text, &mut v).unwrap();
 34 | 
 35 |         assert_eq!(expect.as_bytes(), v.as_slice());
 36 |     }
 37 | }
 38 | 
 39 | #[test]
 40 | fn decode_script() {
 41 |     for (text, expect) in SCRIPT_CASES.iter().copied() {
 42 |         assert_eq!(expect, html_escape::decode_script(text));
 43 |     }
 44 | }
 45 | 
 46 | #[test]
 47 | fn decode_script_to_string() {
 48 |     for (text, expect) in SCRIPT_CASES.iter().copied() {
 49 |         assert_eq!(expect, html_escape::decode_script_to_string(text, &mut String::new()));
 50 |     }
 51 | }
 52 | 
 53 | #[cfg(feature = "std")]
 54 | #[test]
 55 | fn decode_script_to_writer() {
 56 |     for (text, expect) in SCRIPT_CASES.iter().copied() {
 57 |         let mut v = Vec::new();
 58 |         html_escape::decode_script_to_writer(text, &mut v).unwrap();
 59 | 
 60 |         assert_eq!(expect.as_bytes(), v.as_slice());
 61 |     }
 62 | }
 63 | 
 64 | const SCRIPT_SINGLE_QUOTED_CASES: [(&str, &str); 14] = [
 65 |     ("", ""),
 66 |     ("哈囉，中文！", "哈囉，中文！"),
 67 |     (r"alert(\'<script><\/scrIpt >\');", "alert('<script></scrIpt >');"),
 68 |     (
 69 |         "alert(\"<script><\\/script>\");alert(\\'<script><\\/script >\\');",
 70 |         "alert(\"<script></script>\");alert('<script></script >');",
 71 |     ),
 72 |     (r"alert(\'<\!--\');", "alert('<!--');"),
 73 |     ("alert(\"<\\!-- -->\");alert(\\'<\\!--\\');", "alert(\"<!-- -->\");alert('<!--');"),
 74 |     (r"<\'/script>", "<'/script>"),
 75 |     (r"\'<\'/script>", "'<'/script>"),
 76 |     (r"</scri\'pt>", "</scri'pt>"),
 77 |     (r"\'</scri\'pt>", "'</scri'pt>"),
 78 |     (r"<\'!--", "<'!--"),
 79 |     (r"\'<\'!--", "'<'!--"),
 80 |     (r"<!-\'-", "<!-'-"),
 81 |     (r"\'<!-\'-", "'<!-'-"),
 82 | ];
 83 | 
 84 | #[test]
 85 | fn encode_script_single_quoted_text() {
 86 |     for (expect, text) in SCRIPT_SINGLE_QUOTED_CASES.iter().copied() {
 87 |         assert_eq!(expect, html_escape::encode_script_single_quoted_text(text));
 88 |     }
 89 | }
 90 | 
 91 | #[test]
 92 | fn encode_script_single_quoted_text_to_string() {
 93 |     for (expect, text) in SCRIPT_SINGLE_QUOTED_CASES.iter().copied() {
 94 |         assert_eq!(
 95 |             expect,
 96 |             html_escape::encode_script_single_quoted_text_to_string(text, &mut String::new())
 97 |         );
 98 |     }
 99 | }
100 | 
101 | #[cfg(feature = "std")]
102 | #[test]
103 | fn encode_script_single_quoted_text_to_writer() {
104 |     for (expect, text) in SCRIPT_SINGLE_QUOTED_CASES.iter().copied() {
105 |         let mut v = Vec::new();
106 |         html_escape::encode_script_single_quoted_text_to_writer(text, &mut v).unwrap();
107 | 
108 |         assert_eq!(expect.as_bytes(), v.as_slice());
109 |     }
110 | }
111 | 
112 | #[test]
113 | fn decode_script_single_quoted_text() {
114 |     for (text, expect) in SCRIPT_SINGLE_QUOTED_CASES.iter().copied() {
115 |         assert_eq!(expect, html_escape::decode_script_single_quoted_text(text));
116 |     }
117 | }
118 | 
119 | #[test]
120 | fn decode_script_single_quoted_text_to_string() {
121 |     for (text, expect) in SCRIPT_SINGLE_QUOTED_CASES.iter().copied() {
122 |         assert_eq!(
123 |             expect,
124 |             html_escape::decode_script_single_quoted_text_to_string(text, &mut String::new())
125 |         );
126 |     }
127 | }
128 | 
129 | #[cfg(feature = "std")]
130 | #[test]
131 | fn decode_script_single_quoted_text_to_writer() {
132 |     for (text, expect) in SCRIPT_SINGLE_QUOTED_CASES.iter().copied() {
133 |         let mut v = Vec::new();
134 |         html_escape::decode_script_single_quoted_text_to_writer(text, &mut v).unwrap();
135 | 
136 |         assert_eq!(expect.as_bytes(), v.as_slice());
137 |     }
138 | }
139 | 
140 | const SCRIPT_QUOTED_CASES: [(&str, &str); 7] = [
141 |     ("", ""),
142 |     ("哈囉，中文！", "哈囉，中文！"),
143 |     (r"alert(\'<script><\/scrIpt >\');", "alert('<script></scrIpt >');"),
144 |     (
145 |         "alert(\\\"<script><\\/script>\\\");alert(\\'<script><\\/script >\\');",
146 |         "alert(\"<script></script>\");alert('<script></script >');",
147 |     ),
148 |     (r"<\/script>1\'2\'3", "</script>1'2'3"),
149 |     (r"alert(\'<\!--\');", "alert('<!--');"),
150 |     ("alert(\\\"<\\!-- -->\\\");alert(\\'<\\!--\\');", "alert(\"<!-- -->\");alert('<!--');"),
151 | ];
152 | 
153 | #[test]
154 | fn encode_script_quoted_text() {
155 |     for (expect, text) in SCRIPT_QUOTED_CASES.iter().copied() {
156 |         assert_eq!(expect, html_escape::encode_script_quoted_text(text));
157 |     }
158 | }
159 | 
160 | #[test]
161 | fn encode_script_quoted_text_to_string() {
162 |     for (expect, text) in SCRIPT_QUOTED_CASES.iter().copied() {
163 |         assert_eq!(
164 |             expect,
165 |             html_escape::encode_script_quoted_text_to_string(text, &mut String::new())
166 |         );
167 |     }
168 | }
169 | 
170 | #[cfg(feature = "std")]
171 | #[test]
172 | fn encode_script_quoted_text_to_writer() {
173 |     for (expect, text) in SCRIPT_QUOTED_CASES.iter().copied() {
174 |         let mut v = Vec::new();
175 |         html_escape::encode_script_quoted_text_to_writer(text, &mut v).unwrap();
176 | 
177 |         assert_eq!(expect.as_bytes(), v.as_slice());
178 |     }
179 | }
180 | 
181 | #[test]
182 | fn decode_script_quoted_text() {
183 |     for (text, expect) in SCRIPT_QUOTED_CASES.iter().copied() {
184 |         assert_eq!(expect, html_escape::decode_script_quoted_text(text));
185 |     }
186 | }
187 | 
188 | #[test]
189 | fn decode_script_quoted_text_to_string() {
190 |     for (text, expect) in SCRIPT_QUOTED_CASES.iter().copied() {
191 |         assert_eq!(
192 |             expect,
193 |             html_escape::decode_script_quoted_text_to_string(text, &mut String::new())
194 |         );
195 |     }
196 | }
197 | 
198 | #[cfg(feature = "std")]
199 | #[test]
200 | fn decode_script_quoted_text_to_writer() {
201 |     for (text, expect) in SCRIPT_QUOTED_CASES.iter().copied() {
202 |         let mut v = Vec::new();
203 |         html_escape::decode_script_quoted_text_to_writer(text, &mut v).unwrap();
204 | 
205 |         assert_eq!(expect.as_bytes(), v.as_slice());
206 |     }
207 | }
208 | 
209 | const STYLE_CASES: [(&str, &str); 7] = [
210 |     ("", ""),
211 |     ("哈囉，中文！", "哈囉，中文！"),
212 |     (r"div::after { content: '<style><\/stYle >';}", "div::after { content: '<style></stYle >';}"),
213 |     (
214 |         r"div::after { content: '<style><\/style>';} label::after { content: '<style><\/style >';}",
215 |         "div::after { content: '<style></style>';} label::after { content: '<style></style >';}",
216 |     ),
217 |     (r"div::after { content: '<\!--';}", "div::after { content: '<!--';}"),
218 |     (
219 |         r"div::after { content: '<\!-- -->';} label::after { content: '<\!--';}",
220 |         "div::after { content: '<!-- -->';} label::after { content: '<!--';}",
221 |     ),
222 |     (
223 |         r"div::after { content: '<style><\!--<\/style>';}",
224 |         "div::after { content: '<style><!--</style>';}",
225 |     ),
226 | ];
227 | 
228 | #[test]
229 | fn encode_style() {
230 |     for (expect, text) in STYLE_CASES.iter().copied() {
231 |         assert_eq!(expect, html_escape::encode_style(text));
232 |     }
233 | }
234 | 
235 | #[test]
236 | fn encode_style_to_string() {
237 |     for (expect, text) in STYLE_CASES.iter().copied() {
238 |         assert_eq!(expect, html_escape::encode_style_to_string(text, &mut String::new()));
239 |     }
240 | }
241 | 
242 | #[cfg(feature = "std")]
243 | #[test]
244 | fn encode_style_to_writer() {
245 |     for (expect, text) in STYLE_CASES.iter().copied() {
246 |         let mut v = Vec::new();
247 |         html_escape::encode_style_to_writer(text, &mut v).unwrap();
248 | 
249 |         assert_eq!(expect.as_bytes(), v.as_slice());
250 |     }
251 | }
252 | 
253 | #[test]
254 | fn decode_style() {
255 |     for (text, expect) in STYLE_CASES.iter().copied() {
256 |         assert_eq!(expect, html_escape::decode_style(text));
257 |     }
258 | }
259 | 
260 | #[test]
261 | fn decode_style_to_string() {
262 |     for (text, expect) in STYLE_CASES.iter().copied() {
263 |         assert_eq!(expect, html_escape::decode_style_to_string(text, &mut String::new()));
264 |     }
265 | }
266 | 
267 | #[cfg(feature = "std")]
268 | #[test]
269 | fn decode_style_to_writer() {
270 |     for (text, expect) in STYLE_CASES.iter().copied() {
271 |         let mut v = Vec::new();
272 |         html_escape::decode_style_to_writer(text, &mut v).unwrap();
273 | 
274 |         assert_eq!(expect.as_bytes(), v.as_slice());
275 |     }
276 | }
277 | 
278 | const STYLE_SINGLE_QUOTED_CASES: [(&str, &str); 14] = [
279 |     ("", ""),
280 |     ("哈囉，中文！", "哈囉，中文！"),
281 |     (
282 |         r"div::after { content: \'<style><\/stYle >\';}",
283 |         "div::after { content: '<style></stYle >';}",
284 |     ),
285 |     (
286 |         "div::after { content: \"<style><\\/style>\";} label::after { content: \
287 |          \\'<style><\\/style >\\';}",
288 |         "div::after { content: \"<style></style>\";} label::after { content: '<style></style >';}",
289 |     ),
290 |     (r"alert(\'<\!--\');", "alert('<!--');"),
291 |     ("alert(\"<\\!-- -->\");alert(\\'<\\!--\\');", "alert(\"<!-- -->\");alert('<!--');"),
292 |     (r"<\'/style>", "<'/style>"),
293 |     (r"\'<\'/style>", "'<'/style>"),
294 |     (r"</sty\'le>", "</sty'le>"),
295 |     (r"\'</sty\'le>", "'</sty'le>"),
296 |     (r"<\'!--", "<'!--"),
297 |     (r"\'<\'!--", "'<'!--"),
298 |     (r"<!-\'-", "<!-'-"),
299 |     (r"\'<!-\'-", "'<!-'-"),
300 | ];
301 | 
302 | #[test]
303 | fn encode_style_single_quoted_text() {
304 |     for (expect, text) in STYLE_SINGLE_QUOTED_CASES.iter().copied() {
305 |         assert_eq!(expect, html_escape::encode_style_single_quoted_text(text));
306 |     }
307 | }
308 | 
309 | #[test]
310 | fn encode_style_single_quoted_text_to_string() {
311 |     for (expect, text) in STYLE_SINGLE_QUOTED_CASES.iter().copied() {
312 |         assert_eq!(
313 |             expect,
314 |             html_escape::encode_style_single_quoted_text_to_string(text, &mut String::new())
315 |         );
316 |     }
317 | }
318 | 
319 | #[cfg(feature = "std")]
320 | #[test]
321 | fn encode_style_single_quoted_text_to_writer() {
322 |     for (expect, text) in STYLE_SINGLE_QUOTED_CASES.iter().copied() {
323 |         let mut v = Vec::new();
324 |         html_escape::encode_style_single_quoted_text_to_writer(text, &mut v).unwrap();
325 | 
326 |         assert_eq!(expect.as_bytes(), v.as_slice());
327 |     }
328 | }
329 | 
330 | #[test]
331 | fn decode_style_single_quoted_text() {
332 |     for (text, expect) in STYLE_SINGLE_QUOTED_CASES.iter().copied() {
333 |         assert_eq!(expect, html_escape::decode_style_single_quoted_text(text));
334 |     }
335 | }
336 | 
337 | #[test]
338 | fn decode_style_single_quoted_text_to_string() {
339 |     for (text, expect) in STYLE_SINGLE_QUOTED_CASES.iter().copied() {
340 |         assert_eq!(
341 |             expect,
342 |             html_escape::decode_style_single_quoted_text_to_string(text, &mut String::new())
343 |         );
344 |     }
345 | }
346 | 
347 | #[cfg(feature = "std")]
348 | #[test]
349 | fn decode_style_single_quoted_text_to_writer() {
350 |     for (text, expect) in STYLE_SINGLE_QUOTED_CASES.iter().copied() {
351 |         let mut v = Vec::new();
352 |         html_escape::decode_style_single_quoted_text_to_writer(text, &mut v).unwrap();
353 | 
354 |         assert_eq!(expect.as_bytes(), v.as_slice());
355 |     }
356 | }
357 | 
358 | const STYLE_QUOTED_CASES: [(&str, &str); 7] = [
359 |     ("", ""),
360 |     ("哈囉，中文！", "哈囉，中文！"),
361 |     (
362 |         r"div::after { content: \'<style><\/stYle >\';}",
363 |         "div::after { content: '<style></stYle >';}",
364 |     ),
365 |     (
366 |         "div::after { content: \\\"<style><\\/style>\\\";} label::after { content: \
367 |          \\'<style><\\/style >\\';}",
368 |         "div::after { content: \"<style></style>\";} label::after { content: '<style></style >';}",
369 |     ),
370 |     (r"<\/style>1\'2\'3", "</style>1'2'3"),
371 |     (r"alert(\'<\!--\');", "alert('<!--');"),
372 |     ("alert(\\\"<\\!-- -->\\\");alert(\\'<\\!--\\');", "alert(\"<!-- -->\");alert('<!--');"),
373 | ];
374 | 
375 | #[test]
376 | fn encode_style_quoted_text() {
377 |     for (expect, text) in STYLE_QUOTED_CASES.iter().copied() {
378 |         assert_eq!(expect, html_escape::encode_style_quoted_text(text));
379 |     }
380 | }
381 | 
382 | #[test]
383 | fn encode_style_quoted_text_to_string() {
384 |     for (expect, text) in STYLE_QUOTED_CASES.iter().copied() {
385 |         assert_eq!(
386 |             expect,
387 |             html_escape::encode_style_quoted_text_to_string(text, &mut String::new())
388 |         );
389 |     }
390 | }
391 | 
392 | #[cfg(feature = "std")]
393 | #[test]
394 | fn encode_style_quoted_text_to_writer() {
395 |     for (expect, text) in STYLE_QUOTED_CASES.iter().copied() {
396 |         let mut v = Vec::new();
397 |         html_escape::encode_style_quoted_text_to_writer(text, &mut v).unwrap();
398 | 
399 |         assert_eq!(expect.as_bytes(), v.as_slice());
400 |     }
401 | }
402 | 
403 | #[test]
404 | fn decode_style_quoted_text() {
405 |     for (text, expect) in STYLE_QUOTED_CASES.iter().copied() {
406 |         assert_eq!(expect, html_escape::decode_style_quoted_text(text));
407 |     }
408 | }
409 | 
410 | #[test]
411 | fn decode_style_quoted_text_to_string() {
412 |     for (text, expect) in STYLE_QUOTED_CASES.iter().copied() {
413 |         assert_eq!(
414 |             expect,
415 |             html_escape::decode_style_quoted_text_to_string(text, &mut String::new())
416 |         );
417 |     }
418 | }
419 | 
420 | #[cfg(feature = "std")]
421 | #[test]
422 | fn decode_style_quoted_text_to_writer() {
423 |     for (text, expect) in STYLE_QUOTED_CASES.iter().copied() {
424 |         let mut v = Vec::new();
425 |         html_escape::decode_style_quoted_text_to_writer(text, &mut v).unwrap();
426 | 
427 |         assert_eq!(expect.as_bytes(), v.as_slice());
428 |     }
429 | }
430 | 


--------------------------------------------------------------------------------
/tests/html_entity.rs:
--------------------------------------------------------------------------------
  1 | const TEXT_MINIMAL_CASES: [(&str, &str); 7] = [
  2 |     ("", ""),
  3 |     ("哈囉，中文！", "哈囉，中文！"),
  4 |     ("麵包 &amp; butter", "麵包 & butter"),
  5 |     ("\"bread\" &amp; 奶油", "\"bread\" & 奶油"),
  6 |     ("&lt; less than", "< less than"),
  7 |     ("greater than >", "greater than >"),
  8 |     ("https://magiclen.org", "https://magiclen.org"),
  9 | ];
 10 | 
 11 | #[test]
 12 | fn encode_text_minimal() {
 13 |     for (expect, text) in TEXT_MINIMAL_CASES.iter().copied() {
 14 |         assert_eq!(expect, html_escape::encode_text_minimal(text));
 15 |     }
 16 | }
 17 | 
 18 | #[test]
 19 | fn encode_text_minimal_to_string() {
 20 |     for (expect, text) in TEXT_MINIMAL_CASES.iter().copied() {
 21 |         assert_eq!(expect, html_escape::encode_text_minimal_to_string(text, &mut String::new()));
 22 |     }
 23 | }
 24 | 
 25 | #[cfg(feature = "std")]
 26 | #[test]
 27 | fn encode_text_minimal_to_writer() {
 28 |     for (expect, text) in TEXT_MINIMAL_CASES.iter().copied() {
 29 |         let mut v = Vec::new();
 30 |         html_escape::encode_text_minimal_to_writer(text, &mut v).unwrap();
 31 | 
 32 |         assert_eq!(expect.as_bytes(), v.as_slice());
 33 |     }
 34 | }
 35 | 
 36 | #[test]
 37 | fn decode_text_minimal() {
 38 |     for (text, expect) in TEXT_MINIMAL_CASES.iter().copied() {
 39 |         assert_eq!(expect, html_escape::decode_html_entities(text));
 40 |     }
 41 | }
 42 | 
 43 | #[test]
 44 | fn decode_text_minimal_to_string() {
 45 |     for (text, expect) in TEXT_MINIMAL_CASES.iter().copied() {
 46 |         assert_eq!(expect, html_escape::decode_html_entities_to_string(text, &mut String::new()));
 47 |     }
 48 | }
 49 | 
 50 | #[cfg(feature = "std")]
 51 | #[test]
 52 | fn decode_text_minimal_to_writer() {
 53 |     for (text, expect) in TEXT_MINIMAL_CASES.iter().copied() {
 54 |         let mut v = Vec::new();
 55 |         html_escape::decode_html_entities_to_writer(text, &mut v).unwrap();
 56 | 
 57 |         assert_eq!(expect.as_bytes(), v.as_slice());
 58 |     }
 59 | }
 60 | 
 61 | const SAFE_CASES: [(&str, &str); 7] = [
 62 |     ("", ""),
 63 |     ("哈囉，中文！", "哈囉，中文！"),
 64 |     ("麵包 &amp; butter", "麵包 & butter"),
 65 |     ("&quot;bread&quot; &amp; 奶油", "\"bread\" & 奶油"),
 66 |     ("&lt; less than", "< less than"),
 67 |     ("greater than &gt;", "greater than >"),
 68 |     ("https:&#x2F;&#x2F;magiclen.org", "https://magiclen.org"),
 69 | ];
 70 | 
 71 | #[test]
 72 | fn encode_safe() {
 73 |     for (expect, text) in SAFE_CASES.iter().copied() {
 74 |         assert_eq!(expect, html_escape::encode_safe(text));
 75 |     }
 76 | }
 77 | 
 78 | #[cfg(feature = "std")]
 79 | #[test]
 80 | fn encode_safe_to_string() {
 81 |     for (expect, text) in SAFE_CASES.iter().copied() {
 82 |         assert_eq!(expect, html_escape::encode_safe_to_string(text, &mut String::new()));
 83 |     }
 84 | }
 85 | 
 86 | #[cfg(feature = "std")]
 87 | #[test]
 88 | fn encode_safe_to_writer() {
 89 |     for (expect, text) in SAFE_CASES.iter().copied() {
 90 |         let mut v = Vec::new();
 91 |         html_escape::encode_safe_to_writer(text, &mut v).unwrap();
 92 | 
 93 |         assert_eq!(expect.as_bytes(), v.as_slice());
 94 |     }
 95 | }
 96 | 
 97 | #[test]
 98 | fn decode_safe() {
 99 |     for (text, expect) in SAFE_CASES.iter().copied() {
100 |         assert_eq!(expect, html_escape::decode_html_entities(text));
101 |     }
102 | }
103 | 
104 | #[cfg(feature = "std")]
105 | #[test]
106 | fn decode_safe_to_string() {
107 |     for (text, expect) in SAFE_CASES.iter().copied() {
108 |         assert_eq!(expect, html_escape::decode_html_entities_to_string(text, &mut String::new()));
109 |     }
110 | }
111 | 
112 | #[cfg(feature = "std")]
113 | #[test]
114 | fn decode_safe_to_writer() {
115 |     for (text, expect) in SAFE_CASES.iter().copied() {
116 |         let mut v = Vec::new();
117 |         html_escape::decode_html_entities_to_writer(text, &mut v).unwrap();
118 | 
119 |         assert_eq!(expect.as_bytes(), v.as_slice());
120 |     }
121 | }
122 | 
123 | const UNQUOTED_ATTRIBUTE_CASES: [(&str, &str); 7] = [
124 |     ("", ""),
125 |     ("哈囉，中文！", "哈囉，中文！"),
126 |     ("&quot;bread&quot;&#x20;&amp;&#x20;奶油", "\"bread\" & 奶油"),
127 |     ("&lt;&#x20;less&#x20;than", "< less than"),
128 |     ("greater&#x20;than&#x20;&gt;", "greater than >"),
129 |     ("https&#x3A;&#x2F;&#x2F;magiclen&#x2E;org", "https://magiclen.org"),
130 |     ("d&#x2D;none&#x20;m&#x2D;0", "d-none m-0"),
131 | ];
132 | 
133 | #[test]
134 | fn encode_unquoted_attribute() {
135 |     for (expect, text) in UNQUOTED_ATTRIBUTE_CASES.iter().copied() {
136 |         assert_eq!(expect, html_escape::encode_unquoted_attribute(text));
137 |     }
138 | }
139 | 
140 | #[test]
141 | fn encode_unquoted_attribute_to_string() {
142 |     for (expect, text) in UNQUOTED_ATTRIBUTE_CASES.iter().copied() {
143 |         assert_eq!(
144 |             expect,
145 |             html_escape::encode_unquoted_attribute_to_string(text, &mut String::new())
146 |         );
147 |     }
148 | }
149 | 
150 | #[cfg(feature = "std")]
151 | #[test]
152 | fn encode_unquoted_attribute_to_writer() {
153 |     for (expect, text) in UNQUOTED_ATTRIBUTE_CASES.iter().copied() {
154 |         let mut v = Vec::new();
155 |         html_escape::encode_unquoted_attribute_to_writer(text, &mut v).unwrap();
156 | 
157 |         assert_eq!(expect.as_bytes(), v.as_slice());
158 |     }
159 | }
160 | 
161 | #[test]
162 | fn decode_unquoted_attribute() {
163 |     for (text, expect) in UNQUOTED_ATTRIBUTE_CASES.iter().copied() {
164 |         assert_eq!(expect, html_escape::decode_html_entities(text));
165 |     }
166 | }
167 | 
168 | #[test]
169 | fn decode_unquoted_attribute_to_string() {
170 |     for (text, expect) in UNQUOTED_ATTRIBUTE_CASES.iter().copied() {
171 |         assert_eq!(expect, html_escape::decode_html_entities_to_string(text, &mut String::new()));
172 |     }
173 | }
174 | 
175 | #[cfg(feature = "std")]
176 | #[test]
177 | fn decode_unquoted_attribute_to_writer() {
178 |     for (text, expect) in UNQUOTED_ATTRIBUTE_CASES.iter().copied() {
179 |         let mut v = Vec::new();
180 |         html_escape::decode_html_entities_to_writer(text, &mut v).unwrap();
181 | 
182 |         assert_eq!(expect.as_bytes(), v.as_slice());
183 |     }
184 | }
185 | 
186 | // TODO ----------
187 | 
188 | const BIG_NAMES_COMPATIBILITY_CASES: [(&str, &str); 4] =
189 |     [("&", "&AMP;"), ("<", "&LT;"), (">", "&GT;"), ("\"", "&QUOT;")];
190 | 
191 | #[test]
192 | fn decode_html_entities() {
193 |     for (expect, text) in BIG_NAMES_COMPATIBILITY_CASES.iter().copied() {
194 |         assert_eq!(expect, html_escape::decode_html_entities(text));
195 |     }
196 | }
197 | 
198 | #[test]
199 | fn decode_html_entities_to_string() {
200 |     for (expect, text) in BIG_NAMES_COMPATIBILITY_CASES.iter().copied() {
201 |         assert_eq!(expect, html_escape::decode_html_entities_to_string(text, &mut String::new()));
202 |     }
203 | }
204 | 
205 | #[cfg(feature = "std")]
206 | #[test]
207 | fn decode_html_entities_to_writer() {
208 |     for (expect, text) in BIG_NAMES_COMPATIBILITY_CASES.iter().copied() {
209 |         let mut v = Vec::new();
210 |         html_escape::decode_html_entities_to_writer(text, &mut v).unwrap();
211 | 
212 |         assert_eq!(expect.as_bytes(), v.as_slice());
213 |     }
214 | }
215 | 


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