From 8664535c875ca7fa5e8ef070b83acb07ef9bbc0d Mon Sep 17 00:00:00 2001 From: John Messerly Date: Fri, 17 Aug 2012 12:57:28 -0700 Subject: [PATCH] inital port of the tokenizer --- .gitignore | 4 + LICENSE | 23 + README.md | 41 +- codecs.dart | 214 + constants.dart | 3156 ++ encoding_parser.dart | 387 + inputstream.dart | 434 + pubspec.yaml | 8 + tests/data/tokenizer/contentModelFlags.test | 75 + tests/data/tokenizer/domjs.test | 90 + tests/data/tokenizer/entities.test | 283 + tests/data/tokenizer/escapeFlag.test | 33 + tests/data/tokenizer/namedEntities.test | 44189 ++++++++++++++++ tests/data/tokenizer/numericEntities.test | 1313 + tests/data/tokenizer/pendingSpecChanges.test | 7 + tests/data/tokenizer/test1.test | 196 + tests/data/tokenizer/test2.test | 179 + tests/data/tokenizer/test3.test | 6047 +++ tests/data/tokenizer/test4.test | 344 + tests/data/tokenizer/unicodeChars.test | 1295 + .../tokenizer/unicodeCharsProblematic.test | 27 + tests/data/tokenizer/xmlViolation.test | 22 + tests/run.sh | 17 + tests/support.dart | 24 + tests/tokenizer_test.dart | 324 + tokenizer.dart | 1949 + utils.dart | 57 + 27 files changed, 60735 insertions(+), 3 deletions(-) create mode 100644 .gitignore create mode 100644 LICENSE create mode 100644 codecs.dart create mode 100644 constants.dart create mode 100644 encoding_parser.dart create mode 100644 inputstream.dart create mode 100644 pubspec.yaml create mode 100644 tests/data/tokenizer/contentModelFlags.test create mode 100644 tests/data/tokenizer/domjs.test create mode 100644 tests/data/tokenizer/entities.test create mode 100644 tests/data/tokenizer/escapeFlag.test create mode 100644 tests/data/tokenizer/namedEntities.test create mode 100644 tests/data/tokenizer/numericEntities.test create mode 100644 tests/data/tokenizer/pendingSpecChanges.test create mode 100644 tests/data/tokenizer/test1.test create mode 100644 tests/data/tokenizer/test2.test create mode 100644 tests/data/tokenizer/test3.test create mode 100644 tests/data/tokenizer/test4.test create mode 100644 tests/data/tokenizer/unicodeChars.test create mode 100644 tests/data/tokenizer/unicodeCharsProblematic.test create mode 100644 tests/data/tokenizer/xmlViolation.test create mode 100755 tests/run.sh create mode 100644 tests/support.dart create mode 100644 tests/tokenizer_test.dart create mode 100644 tokenizer.dart create mode 100644 utils.dart diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..5906127 --- /dev/null +++ b/.gitignore @@ -0,0 +1,4 @@ +packages/ +pubspec.lock +.project +.children diff --git a/LICENSE b/LICENSE new file mode 100644 index 0000000..d5ee641 --- /dev/null +++ b/LICENSE @@ -0,0 +1,23 @@ +Copyright (c) 2006-2012 The Authors + +Contributors: +James Graham - jg307@cam.ac.uk +Anne van Kesteren - annevankesteren@gmail.com +Lachlan Hunt - lachlan.hunt@lachy.id.au +Matt McDonald - kanashii@kanashii.ca +Sam Ruby - rubys@intertwingly.net +Ian Hickson (Google) - ian@hixie.ch +Thomas Broyer - t.broyer@ltgt.net +Jacques Distler - distler@golem.ph.utexas.edu +Henri Sivonen - hsivonen@iki.fi +Adam Barth - abarth@webkit.org +Eric Seidel - eric@webkit.org +The Mozilla Foundation (contributions from Henri Sivonen since 2008) +David Flanagan (Mozilla) - dflanagan@mozilla.com +Google Inc. (contributed the Dart port) - misc@dartlang.org + +Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. diff --git a/README.md b/README.md index 50187f4..0960c3d 100644 --- a/README.md +++ b/README.md @@ -1,4 +1,39 @@ -html5lib -======== +html5lib in Pure Dart +===================== -html5lib in pure dart \ No newline at end of file +This is a pure [Dart][dart] [html5 parser][html5lib]. It's a port of +[html5lib](http://code.google.com/p/html5lib/) from Python. Since it's 100% +Dart you can use it safely from a script or server side app. + +Eventually the parse tree API will be compatible with [dart:html][d_html], so +the same code will work on the client or the server. + +This library is not finished. These files from the [html5lib directory][files] +still need to be ported: + +* `html5parser.py` +* `ihatexml.py` +* `sanitizer.py` +* `filters/*` +* `serializer/*` +* `treebuilders/*` +* `treewalkers/*` +* most of `tests` + + +Running Tests +------------- + +Dependencies are installed using the [Pub Package Manager][pub]. + + pub install + + # Run command line tests + #export DART_SDK=path/to/dart/sdk + tests/run.sh + + +[dart]: http://www.dartlang.org/ +[html5lib]: http://dev.w3.org/html5/spec/parsing.html +[d_html]: http://api.dartlang.org/docs/continuous/dart_html.html +[files]: http://html5lib.googlecode.com/hg/python/html5lib/ diff --git a/codecs.dart b/codecs.dart new file mode 100644 index 0000000..12254c7 --- /dev/null +++ b/codecs.dart @@ -0,0 +1,214 @@ +/** Decodes bytes using the correct name. See [decodeBytes]. */ +#library('codecs'); + +#import('dart:utf'); +#import('dart:io'); // for DecoderException + +bool hasUtf8Bom(List bytes, [int offset = 0, int length]) { + int end = length != null ? offset + length : bytes.length; + return (offset + 3) <= end && + bytes[offset] == 0xEF && + bytes[offset + 1] == 0xBB && + bytes[offset + 2] == 0xBF; +} + +// TODO(jmesserly): it's unfortunate that this has to be one-shot on the entire +// file, but dart:utf does not expoes stream-based decoders yet. +/** + * Decodes the [bytes] with the provided [encoding] and returns an interator for + * the codepoints. Supports the major unicode encodings as well as ascii and + * and windows-1252 encodings. + */ +Iterable decodeBytes(String encoding, List bytes, + [int offset = 0, int length, + int replacementCodepoint = UNICODE_REPLACEMENT_CHARACTER_CODEPOINT]) { + if (length == null) length = bytes.length; + final replace = replacementCodepoint; + switch (encoding) { + case 'ascii': + bytes = bytes.getRange(offset, length); + // TODO(jmesserly): this was taken from runtime/bin/string_stream.dart + for (int byte in bytes) { + if (byte > 127) { + throw new DecoderException("Illegal ASCII character $byte"); + } + } + return bytes; + + case 'windows-1252': + case 'cp1252': + return decodeWindows1252AsIterable(bytes, offset, length, replace); + + case 'utf-8': + // NOTE: to match the behavior of the other decode functions, we eat the + // utf-8 BOM here. + if (hasUtf8Bom(bytes, offset, length)) { + offset += 3; + length -= 3; + } + return decodeUtf8AsIterable(bytes, offset, length, replace); + + case 'utf-16': + return decodeUtf16AsIterable(bytes, offset, length, replace); + case 'utf-16-be': + return decodeUtf16beAsIterable(bytes, offset, length, true, replace); + case 'utf-16-le': + return decodeUtf16leAsIterable(bytes, offset, length, true, replace); + + case 'utf-32': + return decodeUtf32AsIterable(bytes, offset, length, replace); + case 'utf-32-be': + return decodeUtf32beAsIterable(bytes, offset, length, true, replace); + case 'utf-32-le': + return decodeUtf32leAsIterable(bytes, offset, length, true, replace); + + default: + throw new IllegalArgumentException('Encoding $encoding not supported'); + } +} + + +/** + * Given a UCS-2 string which may contain UTF-16 surrogate pairs, converts to + * a correctly encoded Dart string. If the [input] string does not contain + * surrogate pairs, that string instance will be returned unmodified. + * + * This is useful for fixing strings returned by [JSON.parse], if the JSON + * has UTF-16 encoded via surrogate pairs of characters. For example, + * `"\ud835\udd04"` should translate to a one character stirng with the code + * point `0x01d504`. + */ +String decodeUtf16Surrogates(String input) { + // Note: don't allocate anything until we know we we need it. + List newCodes = null; + for (int i = 0; i < input.length; i++) { + var c = input.charCodeAt(i); + if (0xD800 <= c && c <= 0xDBFF) { + int next = i + 1; + if (next < input.length) { + var d = input.charCodeAt(next); + if (0xDC00 <= d && d <= 0xDFFF) { + if (newCodes == null) { + newCodes = []; + for (int j = 0; j < i; j++) newCodes.add(input.charCodeAt(j)); + } + c = 0x10000 + ((c - 0xD800) << 10) + (d - 0xDC00); + i = next; + } + } + } + if (newCodes != null) newCodes.add(c); + } + + if (newCodes == null) return input; + return codepointsToString(newCodes); +} + + +/** + * Decodes [windows-1252](http://en.wikipedia.org/wiki/Windows-1252) bytes as an + * iterable. Thus, the consumer can only convert as much of the input as needed. + * Set the [replacementCharacter] to null to throw an [IllegalArgumentException] + * rather than replace the bad value. + */ +IterableWindows1252Decoder decodeWindows1252AsIterable(List bytes, + [int offset = 0, int length, + int replacementCodepoint = UNICODE_REPLACEMENT_CHARACTER_CODEPOINT]) { + return new IterableWindows1252Decoder(bytes, offset, length, + replacementCodepoint); +} + + +/** + * Return type of [decodeWindows1252AsIterable] and variants. The Iterable type + * provides an iterator on demand and the iterator will only translate bytes + * as requested by the user of the iterator. (Note: results are not cached.) + */ +class IterableWindows1252Decoder implements Iterable { + final List bytes; + final int offset; + final int length; + final int replacementCodepoint; + + IterableWindows1252Decoder(List this.bytes, [int this.offset = 0, + int this.length = null, + int this.replacementCodepoint = UNICODE_REPLACEMENT_CHARACTER_CODEPOINT]); + + Windows1252Decoder iterator() => new Windows1252Decoder(bytes, offset, length, + replacementCodepoint); +} + + +/** + * Provides an iterator of Unicode codepoints from windows-1252 encoded bytes. + * The parameters can set an offset into a list of bytes (as int), limit the + * length of the values to be decoded, and override the default Unicode + * replacement character. Set the replacementCharacter to null to throw an + * IllegalArgumentException rather than replace the bad value. The return value + * from this method can be used as an Iterable (e.g. in a for-loop). + */ +class Windows1252Decoder implements Iterator { + final int replacementCodepoint; + final List _bytes; + int _offset; + final int _length; + + Windows1252Decoder(List bytes, [int offset = 0, int length, + this.replacementCodepoint = UNICODE_REPLACEMENT_CHARACTER_CODEPOINT]) + : _bytes = bytes, + _offset = offset, + _length = length == null ? bytes.length : length; + + bool hasNext() => _offset < _length; + + int next() { + if (!hasNext()) throw const NoMoreElementsException(); + return _mapChar(_bytes[_offset++]); + } + + int _mapChar(int char) { + // TODO(jmesserly): this is duplicating entitiesWindows1252 and + // replacementCharacters from constants.dart + switch (char) { + case 0x80: return 0x20AC; // EURO SIGN + case 0x82: return 0x201A; // SINGLE LOW-9 QUOTATION MARK + case 0x83: return 0x0192; // LATIN SMALL LETTER F WITH HOOK + case 0x84: return 0x201E; // DOUBLE LOW-9 QUOTATION MARK + case 0x85: return 0x2026; // HORIZONTAL ELLIPSIS + case 0x86: return 0x2020; // DAGGER + case 0x87: return 0x2021; // DOUBLE DAGGER + case 0x88: return 0x02C6; // MODIFIER LETTER CIRCUMFLEX ACCENT + case 0x89: return 0x2030; // PER MILLE SIGN + case 0x8A: return 0x0160; // LATIN CAPITAL LETTER S WITH CARON + case 0x8B: return 0x2039; // SINGLE LEFT-POINTING ANGLE QUOTATION MARK + case 0x8C: return 0x0152; // LATIN CAPITAL LIGATURE OE + case 0x8E: return 0x017D; // LATIN CAPITAL LETTER Z WITH CARON + case 0x91: return 0x2018; // LEFT SINGLE QUOTATION MARK + case 0x92: return 0x2019; // RIGHT SINGLE QUOTATION MARK + case 0x93: return 0x201C; // LEFT DOUBLE QUOTATION MARK + case 0x94: return 0x201D; // RIGHT DOUBLE QUOTATION MARK + case 0x95: return 0x2022; // BULLET + case 0x96: return 0x2013; // EN DASH + case 0x97: return 0x2014; // EM DASH + case 0x98: return 0x02DC; // SMALL TILDE + case 0x99: return 0x2122; // TRADE MARK SIGN + case 0x9A: return 0x0161; // LATIN SMALL LETTER S WITH CARON + case 0x9B: return 0x203A; // SINGLE RIGHT-POINTING ANGLE QUOTATION MARK + case 0x9C: return 0x0153; // LATIN SMALL LIGATURE OE + case 0x9E: return 0x017E; // LATIN SMALL LETTER Z WITH CARON + case 0x9F: return 0x0178; // LATIN CAPITAL LETTER Y WITH DIAERESIS + + case 0x81: + case 0x8D: + case 0x8F: + case 0x90: + case 0x9D: + if (replacementCodepoint == null) { + throw new IllegalArgumentException( + "Invalid windows-1252 code point $char at $_offset"); + } + return replacementCodepoint; + } + return char; + } +} diff --git a/constants.dart b/constants.dart new file mode 100644 index 0000000..cc4115f --- /dev/null +++ b/constants.dart @@ -0,0 +1,3156 @@ +#library('constants'); + +#import('utils.dart'); + +// TODO(jmesserly): immutable data structures for Set and lists where we +// constructed from non-const data. + +final Object EOF = null; + + +final Map Errors = const { + "null-character": + "Null character in input stream, replaced with U+FFFD.", + "invalid-codepoint": + "Invalid codepoint in stream.", + "incorrectly-placed-solidus": + "Solidus (/) incorrectly placed in tag.", + "incorrect-cr-newline-entity": + "Incorrect CR newline entity, replaced with LF.", + "illegal-windows-1252-entity": + "Entity used with illegal number (windows-1252 reference).", + "cant-convert-numeric-entity": + "Numeric entity couldn't be converted to character " + "(codepoint U+%(charAsInt)08x).", + "illegal-codepoint-for-numeric-entity": + "Numeric entity represents an illegal codepoint: " + "U+%(charAsInt)08x.", + "numeric-entity-without-semicolon": + "Numeric entity didn't end with ';'.", + "expected-numeric-entity-but-got-eof": + "Numeric entity expected. Got end of file instead.", + "expected-numeric-entity": + "Numeric entity expected but none found.", + "named-entity-without-semicolon": + "Named entity didn't end with ';'.", + "expected-named-entity": + "Named entity expected. Got none.", + "attributes-in-end-tag": + "End tag contains unexpected attributes.", + 'self-closing-flag-on-end-tag': + "End tag contains unexpected self-closing flag.", + "expected-tag-name-but-got-right-bracket": + "Expected tag name. Got '>' instead.", + "expected-tag-name-but-got-question-mark": + "Expected tag name. Got '?' instead. (HTML doesn't " + "support processing instructions.)", + "expected-tag-name": + "Expected tag name. Got something else instead", + "expected-closing-tag-but-got-right-bracket": + "Expected closing tag. Got '>' instead. Ignoring ''.", + "expected-closing-tag-but-got-eof": + "Expected closing tag. Unexpected end of file.", + "expected-closing-tag-but-got-char": + "Expected closing tag. Unexpected character '%(data)s' found.", + "eof-in-tag-name": + "Unexpected end of file in the tag name.", + "expected-attribute-name-but-got-eof": + "Unexpected end of file. Expected attribute name instead.", + "eof-in-attribute-name": + "Unexpected end of file in attribute name.", + "invalid-character-in-attribute-name": + "Invalid chracter in attribute name", + "duplicate-attribute": + "Dropped duplicate attribute on tag.", + "expected-end-of-tag-name-but-got-eof": + "Unexpected end of file. Expected = or end of tag.", + "expected-attribute-value-but-got-eof": + "Unexpected end of file. Expected attribute value.", + "expected-attribute-value-but-got-right-bracket": + "Expected attribute value. Got '>' instead.", + 'equals-in-unquoted-attribute-value': + "Unexpected = in unquoted attribute", + 'unexpected-character-in-unquoted-attribute-value': + "Unexpected character in unquoted attribute", + "invalid-character-after-attribute-name": + "Unexpected character after attribute name.", + "unexpected-character-after-attribute-value": + "Unexpected character after attribute value.", + "eof-in-attribute-value-double-quote": + "Unexpected end of file in attribute value (\".", + "eof-in-attribute-value-single-quote": + "Unexpected end of file in attribute value (').", + "eof-in-attribute-value-no-quotes": + "Unexpected end of file in attribute value.", + "unexpected-EOF-after-solidus-in-tag": + "Unexpected end of file in tag. Expected >", + "unexpected-character-after-soldius-in-tag": + "Unexpected character after / in tag. Expected >", + "expected-dashes-or-doctype": + "Expected '--' or 'DOCTYPE'. Not found.", + "unexpected-bang-after-double-dash-in-comment": + "Unexpected ! after -- in comment", + "unexpected-space-after-double-dash-in-comment": + "Unexpected space after -- in comment", + "incorrect-comment": + "Incorrect comment.", + "eof-in-comment": + "Unexpected end of file in comment.", + "eof-in-comment-end-dash": + "Unexpected end of file in comment (-)", + "unexpected-dash-after-double-dash-in-comment": + "Unexpected '-' after '--' found in comment.", + "eof-in-comment-double-dash": + "Unexpected end of file in comment (--).", + "eof-in-comment-end-space-state": + "Unexpected end of file in comment.", + "eof-in-comment-end-bang-state": + "Unexpected end of file in comment.", + "unexpected-char-in-comment": + "Unexpected character in comment found.", + "need-space-after-doctype": + "No space after literal string 'DOCTYPE'.", + "expected-doctype-name-but-got-right-bracket": + "Unexpected > character. Expected DOCTYPE name.", + "expected-doctype-name-but-got-eof": + "Unexpected end of file. Expected DOCTYPE name.", + "eof-in-doctype-name": + "Unexpected end of file in DOCTYPE name.", + "eof-in-doctype": + "Unexpected end of file in DOCTYPE.", + "expected-space-or-right-bracket-in-doctype": + "Expected space or '>'. Got '%(data)s'", + "unexpected-end-of-doctype": + "Unexpected end of DOCTYPE.", + "unexpected-char-in-doctype": + "Unexpected character in DOCTYPE.", + "eof-in-innerhtml": + "XXX innerHTML EOF", + "unexpected-doctype": + "Unexpected DOCTYPE. Ignored.", + "non-html-root": + "html needs to be the first start tag.", + "expected-doctype-but-got-eof": + "Unexpected End of file. Expected DOCTYPE.", + "unknown-doctype": + "Erroneous DOCTYPE.", + "expected-doctype-but-got-chars": + "Unexpected non-space characters. Expected DOCTYPE.", + "expected-doctype-but-got-start-tag": + "Unexpected start tag (%(name)s). Expected DOCTYPE.", + "expected-doctype-but-got-end-tag": + "Unexpected end tag (%(name)s). Expected DOCTYPE.", + "end-tag-after-implied-root": + "Unexpected end tag (%(name)s) after the (implied) root element.", + "expected-named-closing-tag-but-got-eof": + "Unexpected end of file. Expected end tag (%(name)s).", + "two-heads-are-not-better-than-one": + "Unexpected start tag head in existing head. Ignored.", + "unexpected-end-tag": + "Unexpected end tag (%(name)s). Ignored.", + "unexpected-start-tag-out-of-my-head": + "Unexpected start tag (%(name)s) that can be in head. Moved.", + "unexpected-start-tag": + "Unexpected start tag (%(name)s).", + "missing-end-tag": + "Missing end tag (%(name)s).", + "missing-end-tags": + "Missing end tags (%(name)s).", + "unexpected-start-tag-implies-end-tag": + "Unexpected start tag (%(startName)s) " + "implies end tag (%(endName)s).", + "unexpected-start-tag-treated-as": + "Unexpected start tag (%(originalName)s). Treated as %(newName)s.", + "deprecated-tag": + "Unexpected start tag %(name)s. Don't use it!", + "unexpected-start-tag-ignored": + "Unexpected start tag %(name)s. Ignored.", + "expected-one-end-tag-but-got-another": + "Unexpected end tag (%(gotName)s). " + "Missing end tag (%(expectedName)s).", + "end-tag-too-early": + "End tag (%(name)s) seen too early. Expected other end tag.", + "end-tag-too-early-named": + "Unexpected end tag (%(gotName)s). Expected end tag (%(expectedName)s).", + "end-tag-too-early-ignored": + "End tag (%(name)s) seen too early. Ignored.", + "adoption-agency-1.1": + "End tag (%(name)s) violates step 1, " + "paragraph 1 of the adoption agency algorithm.", + "adoption-agency-1.2": + "End tag (%(name)s) violates step 1, " + "paragraph 2 of the adoption agency algorithm.", + "adoption-agency-1.3": + "End tag (%(name)s) violates step 1, " + "paragraph 3 of the adoption agency algorithm.", + "unexpected-end-tag-treated-as": + "Unexpected end tag (%(originalName)s). Treated as %(newName)s.", + "no-end-tag": + "This element (%(name)s) has no end tag.", + "unexpected-implied-end-tag-in-table": + "Unexpected implied end tag (%(name)s) in the table phase.", + "unexpected-implied-end-tag-in-table-body": + "Unexpected implied end tag (%(name)s) in the table body phase.", + "unexpected-char-implies-table-voodoo": + "Unexpected non-space characters in " + "table context caused voodoo mode.", + "unexpected-hidden-input-in-table": + "Unexpected input with type hidden in table context.", + "unexpected-form-in-table": + "Unexpected form in table context.", + "unexpected-start-tag-implies-table-voodoo": + "Unexpected start tag (%(name)s) in " + "table context caused voodoo mode.", + "unexpected-end-tag-implies-table-voodoo": + "Unexpected end tag (%(name)s) in " + "table context caused voodoo mode.", + "unexpected-cell-in-table-body": + "Unexpected table cell start tag (%(name)s) " + "in the table body phase.", + "unexpected-cell-end-tag": + "Got table cell end tag (%(name)s) " + "while required end tags are missing.", + "unexpected-end-tag-in-table-body": + "Unexpected end tag (%(name)s) in the table body phase. Ignored.", + "unexpected-implied-end-tag-in-table-row": + "Unexpected implied end tag (%(name)s) in the table row phase.", + "unexpected-end-tag-in-table-row": + "Unexpected end tag (%(name)s) in the table row phase. Ignored.", + "unexpected-select-in-select": + "Unexpected select start tag in the select phase " + "treated as select end tag.", + "unexpected-input-in-select": + "Unexpected input start tag in the select phase.", + "unexpected-start-tag-in-select": + "Unexpected start tag token (%(name)s in the select phase. " + "Ignored.", + "unexpected-end-tag-in-select": + "Unexpected end tag (%(name)s) in the select phase. Ignored.", + "unexpected-table-element-start-tag-in-select-in-table": + "Unexpected table element start tag (%(name)s) in the select in table phase.", + "unexpected-table-element-end-tag-in-select-in-table": + "Unexpected table element end tag (%(name)s) in the select in table phase.", + "unexpected-char-after-body": + "Unexpected non-space characters in the after body phase.", + "unexpected-start-tag-after-body": + "Unexpected start tag token (%(name)s)" + " in the after body phase.", + "unexpected-end-tag-after-body": + "Unexpected end tag token (%(name)s)" + " in the after body phase.", + "unexpected-char-in-frameset": + "Unepxected characters in the frameset phase. Characters ignored.", + "unexpected-start-tag-in-frameset": + "Unexpected start tag token (%(name)s)" + " in the frameset phase. Ignored.", + "unexpected-frameset-in-frameset-innerhtml": + "Unexpected end tag token (frameset) " + "in the frameset phase (innerHTML).", + "unexpected-end-tag-in-frameset": + "Unexpected end tag token (%(name)s)" + " in the frameset phase. Ignored.", + "unexpected-char-after-frameset": + "Unexpected non-space characters in the " + "after frameset phase. Ignored.", + "unexpected-start-tag-after-frameset": + "Unexpected start tag (%(name)s)" + " in the after frameset phase. Ignored.", + "unexpected-end-tag-after-frameset": + "Unexpected end tag (%(name)s)" + " in the after frameset phase. Ignored.", + "unexpected-end-tag-after-body-innerhtml": + "Unexpected end tag after body(innerHtml)", + "expected-eof-but-got-char": + "Unexpected non-space characters. Expected end of file.", + "expected-eof-but-got-start-tag": + "Unexpected start tag (%(name)s)" + ". Expected end of file.", + "expected-eof-but-got-end-tag": + "Unexpected end tag (%(name)s)" + ". Expected end of file.", + "eof-in-table": + "Unexpected end of file. Expected table content.", + "eof-in-select": + "Unexpected end of file. Expected select content.", + "eof-in-frameset": + "Unexpected end of file. Expected frameset content.", + "eof-in-script-in-script": + "Unexpected end of file. Expected script content.", + "eof-in-foreign-lands": + "Unexpected end of file. Expected foreign content", + "non-void-element-with-trailing-solidus": + "Trailing solidus not allowed on element %(name)s", + "unexpected-html-element-in-foreign-content": + "Element %(name)s not allowed in a non-html context", + "unexpected-end-tag-before-html": + "Unexpected end tag (%(name)s) before html.", + "XXX-undefined-error": + "Undefined error (this sucks and should be fixed", +}; + +final _html_ns = "http://www.w3.org/1999/xhtml"; +final _mathml_ns = "http://www.w3.org/1998/Math/MathML"; +final _svg_ns = "http://www.w3.org/2000/svg"; +final Map namespaces = const { + "html": _html_ns, + "mathml": _mathml_ns, + "svg": _svg_ns, + "xlink": "http://www.w3.org/1999/xlink", + "xml": "http://www.w3.org/XML/1998/namespace", + "xmlns": "http://www.w3.org/2000/xmlns/" +}; + +final scopingElements = const [ + const Pair(_html_ns, "applet"), + const Pair(_html_ns, "caption"), + const Pair(_html_ns, "html"), + const Pair(_html_ns, "marquee"), + const Pair(_html_ns, "object"), + const Pair(_html_ns, "table"), + const Pair(_html_ns, "td"), + const Pair(_html_ns, "th"), + const Pair(_mathml_ns, "mi"), + const Pair(_mathml_ns, "mo"), + const Pair(_mathml_ns, "mn"), + const Pair(_mathml_ns, "ms"), + const Pair(_mathml_ns, "mtext"), + const Pair(_mathml_ns, "annotation-xml"), + const Pair(_svg_ns, "foreignObject"), + const Pair(_svg_ns, "desc"), + const Pair(_svg_ns, "title") +]; + + +final formattingElements = const [ + const Pair(_html_ns, "a"), + const Pair(_html_ns, "b"), + const Pair(_html_ns, "big"), + const Pair(_html_ns, "code"), + const Pair(_html_ns, "em"), + const Pair(_html_ns, "font"), + const Pair(_html_ns, "i"), + const Pair(_html_ns, "nobr"), + const Pair(_html_ns, "s"), + const Pair(_html_ns, "small"), + const Pair(_html_ns, "strike"), + const Pair(_html_ns, "strong"), + const Pair(_html_ns, "tt"), + const Pair(_html_ns, "") +]; + +final specialElements = const [ + const Pair(_html_ns, "address"), + const Pair(_html_ns, "applet"), + const Pair(_html_ns, "area"), + const Pair(_html_ns, "article"), + const Pair(_html_ns, "aside"), + const Pair(_html_ns, "base"), + const Pair(_html_ns, "basefont"), + const Pair(_html_ns, "bgsound"), + const Pair(_html_ns, "blockquote"), + const Pair(_html_ns, "body"), + const Pair(_html_ns, "br"), + const Pair(_html_ns, "button"), + const Pair(_html_ns, "caption"), + const Pair(_html_ns, "center"), + const Pair(_html_ns, "col"), + const Pair(_html_ns, "colgroup"), + const Pair(_html_ns, "command"), + const Pair(_html_ns, "dd"), + const Pair(_html_ns, "details"), + const Pair(_html_ns, "dir"), + const Pair(_html_ns, "div"), + const Pair(_html_ns, "dl"), + const Pair(_html_ns, "dt"), + const Pair(_html_ns, "embed"), + const Pair(_html_ns, "fieldset"), + const Pair(_html_ns, "figure"), + const Pair(_html_ns, "footer"), + const Pair(_html_ns, "form"), + const Pair(_html_ns, "frame"), + const Pair(_html_ns, "frameset"), + const Pair(_html_ns, "h1"), + const Pair(_html_ns, "h2"), + const Pair(_html_ns, "h3"), + const Pair(_html_ns, "h4"), + const Pair(_html_ns, "h5"), + const Pair(_html_ns, "h6"), + const Pair(_html_ns, "head"), + const Pair(_html_ns, "header"), + const Pair(_html_ns, "hr"), + const Pair(_html_ns, "html"), + const Pair(_html_ns, "iframe"), + // Note that image is commented out in the spec as "this isn't an + // element that can end up on the stack, so it doesn't matter," + const Pair(_html_ns, "image"), + const Pair(_html_ns, "img"), + const Pair(_html_ns, "input"), + const Pair(_html_ns, "isindex"), + const Pair(_html_ns, "li"), + const Pair(_html_ns, "link"), + const Pair(_html_ns, "listing"), + const Pair(_html_ns, "marquee"), + const Pair(_html_ns, "men"), + const Pair(_html_ns, "meta"), + const Pair(_html_ns, "nav"), + const Pair(_html_ns, "noembed"), + const Pair(_html_ns, "noframes"), + const Pair(_html_ns, "noscript"), + const Pair(_html_ns, "object"), + const Pair(_html_ns, "ol"), + const Pair(_html_ns, "p"), + const Pair(_html_ns, "param"), + const Pair(_html_ns, "plaintext"), + const Pair(_html_ns, "pre"), + const Pair(_html_ns, "script"), + const Pair(_html_ns, "section"), + const Pair(_html_ns, "select"), + const Pair(_html_ns, "style"), + const Pair(_html_ns, "table"), + const Pair(_html_ns, "tbody"), + const Pair(_html_ns, "td"), + const Pair(_html_ns, "textarea"), + const Pair(_html_ns, "tfoot"), + const Pair(_html_ns, "th"), + const Pair(_html_ns, "thead"), + const Pair(_html_ns, "title"), + const Pair(_html_ns, "tr"), + const Pair(_html_ns, "ul"), + const Pair(_html_ns, "wbr"), + const Pair(_html_ns, "xmp"), + const Pair(_svg_ns, "foreignObject") +]; + +final htmlIntegrationPointElements = const [ + const Pair(_mathml_ns, "annotaion-xml"), + const Pair(_svg_ns, "foreignObject"), + const Pair(_svg_ns, "desc"), + const Pair(_svg_ns, "title") +]; + +final mathmlTextIntegrationPointElements = const [ + const Pair(_mathml_ns, "mi"), + const Pair(_mathml_ns, "mo"), + const Pair(_mathml_ns, "mn"), + const Pair(_mathml_ns, "ms"), + const Pair(_mathml_ns, "mtext") +]; + +final spaceCharacters = " \n\r\t\u000C"; + +final int NEWLINE = 10; +final int RETURN = 13; + +bool isWhitespace(String char) { + if (char == null) return false; + int cc = char.charCodeAt(0); + switch (cc) { + case 9: // '\t' + case NEWLINE: // '\n' + case 12: // '\f' + case RETURN: // '\r' + case 32: // ' ' + return true; + } + return false; +} + +final List tableInsertModeElements = const [ + "table", + "tbody", + "tfoot", + "thead", + "tr" +]; + +// TODO(jmesserly): remove these in favor of the test functions +final asciiLetters = 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ'; + +final ZERO = 48; +final LOWER_A = 97; +final LOWER_Z = 122; +final UPPER_A = 65; +final UPPER_Z = 90; + +bool isLetterOrDigit(String char) => isLetter(char) || isDigit(char); + +// Note: this is intentially ASCII only +bool isLetter(String char) { + if (char == null) return false; + int cc = char.charCodeAt(0); + return cc >= LOWER_A && cc <= LOWER_Z || cc >= UPPER_A && cc <= UPPER_Z; +} + +bool isDigit(String char) { + if (char == null) return false; + int cc = char.charCodeAt(0); + return cc >= ZERO && cc < ZERO + 10; +} + +bool isHexDigit(String char) { + if (char == null) return false; + switch (char.charCodeAt(0)) { + case 48: case 49: case 50: case 51: case 52: // '0' - '4' + case 53: case 54: case 55: case 56: case 57: // '5' - '9' + case 65: case 66: case 67: case 68: case 69: case 70: // 'A' - 'F' + case 97: case 98: case 99: case 100: case 101: case 102: // 'a' - 'f' + return true; + } + return false; +} + +// Note: based on the original Python code, I assume we only want to convert +// ASCII chars to.toLowerCase() case, unlike Dart's toLowerCase function. +String asciiUpper2Lower(String text) { + var result = new List(text.length); + for (int i = 0; i < text.length; i++) { + var c = text.charCodeAt(i); + if (c >= UPPER_A && c <= UPPER_Z) { + c += LOWER_A - UPPER_A; + } + result[i] = c; + } + return new String.fromCharCodes(result); +} + +// Heading elements need to be ordered +final headingElements = const [ + "h1", + "h2", + "h3", + "h4", + "h5", + "h6" +]; + +final voidElements = const [ + "base", + "command", + "event-source", + "link", + "meta", + "hr", + "br", + "img", + "embed", + "param", + "area", + "col", + "input", + "source", + "track" +]; + +final cdataElements = const ['title', 'textarea']; + +final rcdataElements = const [ + 'style', + 'script', + 'xmp', + 'iframe', + 'noembed', + 'noframes', + 'noscript' +]; + +final Map> booleanAttributes = const { + "": const ["irrelevant",], + "style": const ["scoped",], + "img": const ["ismap",], + "audio": const ["autoplay","controls"], + "video": const ["autoplay","controls"], + "script": const ["defer", "async"], + "details": const ["open",], + "datagrid": const ["multiple", "disabled"], + "command": const ["hidden", "disabled", "checked", "default"], + "hr": const ["noshade"], + "men": const ["autosubmit",], + "fieldset": const ["disabled", "readonly"], + "option": const ["disabled", "readonly", "selected"], + "optgroup": const ["disabled", "readonly"], + "button": const ["disabled", "autofocus"], + "input": const ["disabled", "readonly", "required", "autofocus", "checked", "ismap"], + "select": const ["disabled", "readonly", "autofocus", "multiple"], + "output": const ["disabled", "readonly"], +}; + +// entitiesWindows1252 has to be _ordered_ and needs to have an index. It +// therefore can't be a frozenset. +final List entitiesWindows1252 = const [ + 8364, // 0x80 0x20AC EURO SIGN + 65533, // 0x81 UNDEFINED + 8218, // 0x82 0x201A SINGLE LOW-9 QUOTATION MARK + 402, // 0x83 0x0192 LATIN SMALL LETTER F WITH HOOK + 8222, // 0x84 0x201E DOUBLE LOW-9 QUOTATION MARK + 8230, // 0x85 0x2026 HORIZONTAL ELLIPSIS + 8224, // 0x86 0x2020 DAGGER + 8225, // 0x87 0x2021 DOUBLE DAGGER + 710, // 0x88 0x02C6 MODIFIER LETTER CIRCUMFLEX ACCENT + 8240, // 0x89 0x2030 PER MILLE SIGN + 352, // 0x8A 0x0160 LATIN CAPITAL LETTER S WITH CARON + 8249, // 0x8B 0x2039 SINGLE LEFT-POINTING ANGLE QUOTATION MARK + 338, // 0x8C 0x0152 LATIN CAPITAL LIGATURE OE + 65533, // 0x8D UNDEFINED + 381, // 0x8E 0x017D LATIN CAPITAL LETTER Z WITH CARON + 65533, // 0x8F UNDEFINED + 65533, // 0x90 UNDEFINED + 8216, // 0x91 0x2018 LEFT SINGLE QUOTATION MARK + 8217, // 0x92 0x2019 RIGHT SINGLE QUOTATION MARK + 8220, // 0x93 0x201C LEFT DOUBLE QUOTATION MARK + 8221, // 0x94 0x201D RIGHT DOUBLE QUOTATION MARK + 8226, // 0x95 0x2022 BULLET + 8211, // 0x96 0x2013 EN DASH + 8212, // 0x97 0x2014 EM DASH + 732, // 0x98 0x02DC SMALL TILDE + 8482, // 0x99 0x2122 TRADE MARK SIGN + 353, // 0x9A 0x0161 LATIN SMALL LETTER S WITH CARON + 8250, // 0x9B 0x203A SINGLE RIGHT-POINTING ANGLE QUOTATION MARK + 339, // 0x9C 0x0153 LATIN SMALL LIGATURE OE + 65533, // 0x9D UNDEFINED + 382, // 0x9E 0x017E LATIN SMALL LETTER Z WITH CARON + 376 // 0x9F 0x0178 LATIN CAPITAL LETTER Y WITH DIAERESIS +]; + +final xmlEntities = const ['lt;', 'gt;', 'amp;', 'apos;', 'quot;']; + +final Map entities = const { + "AElig": "\xc6", + "AElig;": "\xc6", + "AMP": "&", + "AMP;": "&", + "Aacute": "\xc1", + "Aacute;": "\xc1", + "Abreve;": "\u0102", + "Acirc": "\xc2", + "Acirc;": "\xc2", + "Acy;": "\u0410", + "Afr;": "\u{01d504}", + "Agrave": "\xc0", + "Agrave;": "\xc0", + "Alpha;": "\u0391", + "Amacr;": "\u0100", + "And;": "\u2a53", + "Aogon;": "\u0104", + "Aopf;": "\u{01d538}", + "ApplyFunction;": "\u2061", + "Aring": "\xc5", + "Aring;": "\xc5", + "Ascr;": "\u{01d49c}", + "Assign;": "\u2254", + "Atilde": "\xc3", + "Atilde;": "\xc3", + "Auml": "\xc4", + "Auml;": "\xc4", + "Backslash;": "\u2216", + "Barv;": "\u2ae7", + "Barwed;": "\u2306", + "Bcy;": "\u0411", + "Because;": "\u2235", + "Bernoullis;": "\u212c", + "Beta;": "\u0392", + "Bfr;": "\u{01d505}", + "Bopf;": "\u{01d539}", + "Breve;": "\u02d8", + "Bscr;": "\u212c", + "Bumpeq;": "\u224e", + "CHcy;": "\u0427", + "COPY": "\xa9", + "COPY;": "\xa9", + "Cacute;": "\u0106", + "Cap;": "\u22d2", + "CapitalDifferentialD;": "\u2145", + "Cayleys;": "\u212d", + "Ccaron;": "\u010c", + "Ccedil": "\xc7", + "Ccedil;": "\xc7", + "Ccirc;": "\u0108", + "Cconint;": "\u2230", + "Cdot;": "\u010a", + "Cedilla;": "\xb8", + "CenterDot;": "\xb7", + "Cfr;": "\u212d", + "Chi;": "\u03a7", + "CircleDot;": "\u2299", + "CircleMinus;": "\u2296", + "CirclePlus;": "\u2295", + "CircleTimes;": "\u2297", + "ClockwiseContourIntegral;": "\u2232", + "CloseCurlyDoubleQuote;": "\u201d", + "CloseCurlyQuote;": "\u2019", + "Colon;": "\u2237", + "Colone;": "\u2a74", + "Congruent;": "\u2261", + "Conint;": "\u222f", + "ContourIntegral;": "\u222e", + "Copf;": "\u2102", + "Coproduct;": "\u2210", + "CounterClockwiseContourIntegral;": "\u2233", + "Cross;": "\u2a2f", + "Cscr;": "\u{01d49e}", + "Cup;": "\u22d3", + "CupCap;": "\u224d", + "DD;": "\u2145", + "DDotrahd;": "\u2911", + "DJcy;": "\u0402", + "DScy;": "\u0405", + "DZcy;": "\u040f", + "Dagger;": "\u2021", + "Darr;": "\u21a1", + "Dashv;": "\u2ae4", + "Dcaron;": "\u010e", + "Dcy;": "\u0414", + "Del;": "\u2207", + "Delta;": "\u0394", + "Dfr;": "\u{01d507}", + "DiacriticalAcute;": "\xb4", + "DiacriticalDot;": "\u02d9", + "DiacriticalDoubleAcute;": "\u02dd", + "DiacriticalGrave;": "`", + "DiacriticalTilde;": "\u02dc", + "Diamond;": "\u22c4", + "DifferentialD;": "\u2146", + "Dopf;": "\u{01d53b}", + "Dot;": "\xa8", + "DotDot;": "\u20dc", + "DotEqual;": "\u2250", + "DoubleContourIntegral;": "\u222f", + "DoubleDot;": "\xa8", + "DoubleDownArrow;": "\u21d3", + "DoubleLeftArrow;": "\u21d0", + "DoubleLeftRightArrow;": "\u21d4", + "DoubleLeftTee;": "\u2ae4", + "DoubleLongLeftArrow;": "\u27f8", + "DoubleLongLeftRightArrow;": "\u27fa", + "DoubleLongRightArrow;": "\u27f9", + "DoubleRightArrow;": "\u21d2", + "DoubleRightTee;": "\u22a8", + "DoubleUpArrow;": "\u21d1", + "DoubleUpDownArrow;": "\u21d5", + "DoubleVerticalBar;": "\u2225", + "DownArrow;": "\u2193", + "DownArrowBar;": "\u2913", + "DownArrowUpArrow;": "\u21f5", + "DownBreve;": "\u0311", + "DownLeftRightVector;": "\u2950", + "DownLeftTeeVector;": "\u295e", + "DownLeftVector;": "\u21bd", + "DownLeftVectorBar;": "\u2956", + "DownRightTeeVector;": "\u295f", + "DownRightVector;": "\u21c1", + "DownRightVectorBar;": "\u2957", + "DownTee;": "\u22a4", + "DownTeeArrow;": "\u21a7", + "Downarrow;": "\u21d3", + "Dscr;": "\u{01d49f}", + "Dstrok;": "\u0110", + "ENG;": "\u014a", + "ETH": "\xd0", + "ETH;": "\xd0", + "Eacute": "\xc9", + "Eacute;": "\xc9", + "Ecaron;": "\u011a", + "Ecirc": "\xca", + "Ecirc;": "\xca", + "Ecy;": "\u042d", + "Edot;": "\u0116", + "Efr;": "\u{01d508}", + "Egrave": "\xc8", + "Egrave;": "\xc8", + "Element;": "\u2208", + "Emacr;": "\u0112", + "EmptySmallSquare;": "\u25fb", + "EmptyVerySmallSquare;": "\u25ab", + "Eogon;": "\u0118", + "Eopf;": "\u{01d53c}", + "Epsilon;": "\u0395", + "Equal;": "\u2a75", + "EqualTilde;": "\u2242", + "Equilibrium;": "\u21cc", + "Escr;": "\u2130", + "Esim;": "\u2a73", + "Eta;": "\u0397", + "Euml": "\xcb", + "Euml;": "\xcb", + "Exists;": "\u2203", + "ExponentialE;": "\u2147", + "Fcy;": "\u0424", + "Ffr;": "\u{01d509}", + "FilledSmallSquare;": "\u25fc", + "FilledVerySmallSquare;": "\u25aa", + "Fopf;": "\u{01d53d}", + "ForAll;": "\u2200", + "Fouriertrf;": "\u2131", + "Fscr;": "\u2131", + "GJcy;": "\u0403", + "GT": ">", + "GT;": ">", + "Gamma;": "\u0393", + "Gammad;": "\u03dc", + "Gbreve;": "\u011e", + "Gcedil;": "\u0122", + "Gcirc;": "\u011c", + "Gcy;": "\u0413", + "Gdot;": "\u0120", + "Gfr;": "\u{01d50a}", + "Gg;": "\u22d9", + "Gopf;": "\u{01d53e}", + "GreaterEqual;": "\u2265", + "GreaterEqualLess;": "\u22db", + "GreaterFullEqual;": "\u2267", + "GreaterGreater;": "\u2aa2", + "GreaterLess;": "\u2277", + "GreaterSlantEqual;": "\u2a7e", + "GreaterTilde;": "\u2273", + "Gscr;": "\u{01d4a2}", + "Gt;": "\u226b", + "HARDcy;": "\u042a", + "Hacek;": "\u02c7", + "Hat;": "^", + "Hcirc;": "\u0124", + "Hfr;": "\u210c", + "HilbertSpace;": "\u210b", + "Hopf;": "\u210d", + "HorizontalLine;": "\u2500", + "Hscr;": "\u210b", + "Hstrok;": "\u0126", + "HumpDownHump;": "\u224e", + "HumpEqual;": "\u224f", + "IEcy;": "\u0415", + "IJlig;": "\u0132", + "IOcy;": "\u0401", + "Iacute": "\xcd", + "Iacute;": "\xcd", + "Icirc": "\xce", + "Icirc;": "\xce", + "Icy;": "\u0418", + "Idot;": "\u0130", + "Ifr;": "\u2111", + "Igrave": "\xcc", + "Igrave;": "\xcc", + "Im;": "\u2111", + "Imacr;": "\u012a", + "ImaginaryI;": "\u2148", + "Implies;": "\u21d2", + "Int;": "\u222c", + "Integral;": "\u222b", + "Intersection;": "\u22c2", + "InvisibleComma;": "\u2063", + "InvisibleTimes;": "\u2062", + "Iogon;": "\u012e", + "Iopf;": "\u{01d540}", + "Iota;": "\u0399", + "Iscr;": "\u2110", + "Itilde;": "\u0128", + "Iukcy;": "\u0406", + "Iuml": "\xcf", + "Iuml;": "\xcf", + "Jcirc;": "\u0134", + "Jcy;": "\u0419", + "Jfr;": "\u{01d50d}", + "Jopf;": "\u{01d541}", + "Jscr;": "\u{01d4a5}", + "Jsercy;": "\u0408", + "Jukcy;": "\u0404", + "KHcy;": "\u0425", + "KJcy;": "\u040c", + "Kappa;": "\u039a", + "Kcedil;": "\u0136", + "Kcy;": "\u041a", + "Kfr;": "\u{01d50e}", + "Kopf;": "\u{01d542}", + "Kscr;": "\u{01d4a6}", + "LJcy;": "\u0409", + "LT": "<", + "LT;": "<", + "Lacute;": "\u0139", + "Lambda;": "\u039b", + "Lang;": "\u27ea", + "Laplacetrf;": "\u2112", + "Larr;": "\u219e", + "Lcaron;": "\u013d", + "Lcedil;": "\u013b", + "Lcy;": "\u041b", + "LeftAngleBracket;": "\u27e8", + "LeftArrow;": "\u2190", + "LeftArrowBar;": "\u21e4", + "LeftArrowRightArrow;": "\u21c6", + "LeftCeiling;": "\u2308", + "LeftDoubleBracket;": "\u27e6", + "LeftDownTeeVector;": "\u2961", + "LeftDownVector;": "\u21c3", + "LeftDownVectorBar;": "\u2959", + "LeftFloor;": "\u230a", + "LeftRightArrow;": "\u2194", + "LeftRightVector;": "\u294e", + "LeftTee;": "\u22a3", + "LeftTeeArrow;": "\u21a4", + "LeftTeeVector;": "\u295a", + "LeftTriangle;": "\u22b2", + "LeftTriangleBar;": "\u29cf", + "LeftTriangleEqual;": "\u22b4", + "LeftUpDownVector;": "\u2951", + "LeftUpTeeVector;": "\u2960", + "LeftUpVector;": "\u21bf", + "LeftUpVectorBar;": "\u2958", + "LeftVector;": "\u21bc", + "LeftVectorBar;": "\u2952", + "Leftarrow;": "\u21d0", + "Leftrightarrow;": "\u21d4", + "LessEqualGreater;": "\u22da", + "LessFullEqual;": "\u2266", + "LessGreater;": "\u2276", + "LessLess;": "\u2aa1", + "LessSlantEqual;": "\u2a7d", + "LessTilde;": "\u2272", + "Lfr;": "\u{01d50f}", + "Ll;": "\u22d8", + "Lleftarrow;": "\u21da", + "Lmidot;": "\u013f", + "LongLeftArrow;": "\u27f5", + "LongLeftRightArrow;": "\u27f7", + "LongRightArrow;": "\u27f6", + "Longleftarrow;": "\u27f8", + "Longleftrightarrow;": "\u27fa", + "Longrightarrow;": "\u27f9", + "Lopf;": "\u{01d543}", + "LowerLeftArrow;": "\u2199", + "LowerRightArrow;": "\u2198", + "Lscr;": "\u2112", + "Lsh;": "\u21b0", + "Lstrok;": "\u0141", + "Lt;": "\u226a", + "Map;": "\u2905", + "Mcy;": "\u041c", + "MediumSpace;": "\u205f", + "Mellintrf;": "\u2133", + "Mfr;": "\u{01d510}", + "MinusPlus;": "\u2213", + "Mopf;": "\u{01d544}", + "Mscr;": "\u2133", + "Mu;": "\u039c", + "NJcy;": "\u040a", + "Nacute;": "\u0143", + "Ncaron;": "\u0147", + "Ncedil;": "\u0145", + "Ncy;": "\u041d", + "NegativeMediumSpace;": "\u200b", + "NegativeThickSpace;": "\u200b", + "NegativeThinSpace;": "\u200b", + "NegativeVeryThinSpace;": "\u200b", + "NestedGreaterGreater;": "\u226b", + "NestedLessLess;": "\u226a", + "NewLine;": "\n", + "Nfr;": "\u{01d511}", + "NoBreak;": "\u2060", + "NonBreakingSpace;": "\xa0", + "Nopf;": "\u2115", + "Not;": "\u2aec", + "NotCongruent;": "\u2262", + "NotCupCap;": "\u226d", + "NotDoubleVerticalBar;": "\u2226", + "NotElement;": "\u2209", + "NotEqual;": "\u2260", + "NotEqualTilde;": "\u2242\u0338", + "NotExists;": "\u2204", + "NotGreater;": "\u226f", + "NotGreaterEqual;": "\u2271", + "NotGreaterFullEqual;": "\u2267\u0338", + "NotGreaterGreater;": "\u226b\u0338", + "NotGreaterLess;": "\u2279", + "NotGreaterSlantEqual;": "\u2a7e\u0338", + "NotGreaterTilde;": "\u2275", + "NotHumpDownHump;": "\u224e\u0338", + "NotHumpEqual;": "\u224f\u0338", + "NotLeftTriangle;": "\u22ea", + "NotLeftTriangleBar;": "\u29cf\u0338", + "NotLeftTriangleEqual;": "\u22ec", + "NotLess;": "\u226e", + "NotLessEqual;": "\u2270", + "NotLessGreater;": "\u2278", + "NotLessLess;": "\u226a\u0338", + "NotLessSlantEqual;": "\u2a7d\u0338", + "NotLessTilde;": "\u2274", + "NotNestedGreaterGreater;": "\u2aa2\u0338", + "NotNestedLessLess;": "\u2aa1\u0338", + "NotPrecedes;": "\u2280", + "NotPrecedesEqual;": "\u2aaf\u0338", + "NotPrecedesSlantEqual;": "\u22e0", + "NotReverseElement;": "\u220c", + "NotRightTriangle;": "\u22eb", + "NotRightTriangleBar;": "\u29d0\u0338", + "NotRightTriangleEqual;": "\u22ed", + "NotSquareSubset;": "\u228f\u0338", + "NotSquareSubsetEqual;": "\u22e2", + "NotSquareSuperset;": "\u2290\u0338", + "NotSquareSupersetEqual;": "\u22e3", + "NotSubset;": "\u2282\u20d2", + "NotSubsetEqual;": "\u2288", + "NotSucceeds;": "\u2281", + "NotSucceedsEqual;": "\u2ab0\u0338", + "NotSucceedsSlantEqual;": "\u22e1", + "NotSucceedsTilde;": "\u227f\u0338", + "NotSuperset;": "\u2283\u20d2", + "NotSupersetEqual;": "\u2289", + "NotTilde;": "\u2241", + "NotTildeEqual;": "\u2244", + "NotTildeFullEqual;": "\u2247", + "NotTildeTilde;": "\u2249", + "NotVerticalBar;": "\u2224", + "Nscr;": "\u{01d4a9}", + "Ntilde": "\xd1", + "Ntilde;": "\xd1", + "Nu;": "\u039d", + "OElig;": "\u0152", + "Oacute": "\xd3", + "Oacute;": "\xd3", + "Ocirc": "\xd4", + "Ocirc;": "\xd4", + "Ocy;": "\u041e", + "Odblac;": "\u0150", + "Ofr;": "\u{01d512}", + "Ograve": "\xd2", + "Ograve;": "\xd2", + "Omacr;": "\u014c", + "Omega;": "\u03a9", + "Omicron;": "\u039f", + "Oopf;": "\u{01d546}", + "OpenCurlyDoubleQuote;": "\u201c", + "OpenCurlyQuote;": "\u2018", + "Or;": "\u2a54", + "Oscr;": "\u{01d4aa}", + "Oslash": "\xd8", + "Oslash;": "\xd8", + "Otilde": "\xd5", + "Otilde;": "\xd5", + "Otimes;": "\u2a37", + "Ouml": "\xd6", + "Ouml;": "\xd6", + "OverBar;": "\u203e", + "OverBrace;": "\u23de", + "OverBracket;": "\u23b4", + "OverParenthesis;": "\u23dc", + "PartialD;": "\u2202", + "Pcy;": "\u041f", + "Pfr;": "\u{01d513}", + "Phi;": "\u03a6", + "Pi;": "\u03a0", + "PlusMinus;": "\xb1", + "Poincareplane;": "\u210c", + "Popf;": "\u2119", + "Pr;": "\u2abb", + "Precedes;": "\u227a", + "PrecedesEqual;": "\u2aaf", + "PrecedesSlantEqual;": "\u227c", + "PrecedesTilde;": "\u227e", + "Prime;": "\u2033", + "Product;": "\u220f", + "Proportion;": "\u2237", + "Proportional;": "\u221d", + "Pscr;": "\u{01d4ab}", + "Psi;": "\u03a8", + "QUOT": "\"", + "QUOT;": "\"", + "Qfr;": "\u{01d514}", + "Qopf;": "\u211a", + "Qscr;": "\u{01d4ac}", + "RBarr;": "\u2910", + "REG": "\xae", + "REG;": "\xae", + "Racute;": "\u0154", + "Rang;": "\u27eb", + "Rarr;": "\u21a0", + "Rarrtl;": "\u2916", + "Rcaron;": "\u0158", + "Rcedil;": "\u0156", + "Rcy;": "\u0420", + "Re;": "\u211c", + "ReverseElement;": "\u220b", + "ReverseEquilibrium;": "\u21cb", + "ReverseUpEquilibrium;": "\u296f", + "Rfr;": "\u211c", + "Rho;": "\u03a1", + "RightAngleBracket;": "\u27e9", + "RightArrow;": "\u2192", + "RightArrowBar;": "\u21e5", + "RightArrowLeftArrow;": "\u21c4", + "RightCeiling;": "\u2309", + "RightDoubleBracket;": "\u27e7", + "RightDownTeeVector;": "\u295d", + "RightDownVector;": "\u21c2", + "RightDownVectorBar;": "\u2955", + "RightFloor;": "\u230b", + "RightTee;": "\u22a2", + "RightTeeArrow;": "\u21a6", + "RightTeeVector;": "\u295b", + "RightTriangle;": "\u22b3", + "RightTriangleBar;": "\u29d0", + "RightTriangleEqual;": "\u22b5", + "RightUpDownVector;": "\u294f", + "RightUpTeeVector;": "\u295c", + "RightUpVector;": "\u21be", + "RightUpVectorBar;": "\u2954", + "RightVector;": "\u21c0", + "RightVectorBar;": "\u2953", + "Rightarrow;": "\u21d2", + "Ropf;": "\u211d", + "RoundImplies;": "\u2970", + "Rrightarrow;": "\u21db", + "Rscr;": "\u211b", + "Rsh;": "\u21b1", + "RuleDelayed;": "\u29f4", + "SHCHcy;": "\u0429", + "SHcy;": "\u0428", + "SOFTcy;": "\u042c", + "Sacute;": "\u015a", + "Sc;": "\u2abc", + "Scaron;": "\u0160", + "Scedil;": "\u015e", + "Scirc;": "\u015c", + "Scy;": "\u0421", + "Sfr;": "\u{01d516}", + "ShortDownArrow;": "\u2193", + "ShortLeftArrow;": "\u2190", + "ShortRightArrow;": "\u2192", + "ShortUpArrow;": "\u2191", + "Sigma;": "\u03a3", + "SmallCircle;": "\u2218", + "Sopf;": "\u{01d54a}", + "Sqrt;": "\u221a", + "Square;": "\u25a1", + "SquareIntersection;": "\u2293", + "SquareSubset;": "\u228f", + "SquareSubsetEqual;": "\u2291", + "SquareSuperset;": "\u2290", + "SquareSupersetEqual;": "\u2292", + "SquareUnion;": "\u2294", + "Sscr;": "\u{01d4ae}", + "Star;": "\u22c6", + "Sub;": "\u22d0", + "Subset;": "\u22d0", + "SubsetEqual;": "\u2286", + "Succeeds;": "\u227b", + "SucceedsEqual;": "\u2ab0", + "SucceedsSlantEqual;": "\u227d", + "SucceedsTilde;": "\u227f", + "SuchThat;": "\u220b", + "Sum;": "\u2211", + "Sup;": "\u22d1", + "Superset;": "\u2283", + "SupersetEqual;": "\u2287", + "Supset;": "\u22d1", + "THORN": "\xde", + "THORN;": "\xde", + "TRADE;": "\u2122", + "TSHcy;": "\u040b", + "TScy;": "\u0426", + "Tab;": "\t", + "Tau;": "\u03a4", + "Tcaron;": "\u0164", + "Tcedil;": "\u0162", + "Tcy;": "\u0422", + "Tfr;": "\u{01d517}", + "Therefore;": "\u2234", + "Theta;": "\u0398", + "ThickSpace;": "\u205f\u200a", + "ThinSpace;": "\u2009", + "Tilde;": "\u223c", + "TildeEqual;": "\u2243", + "TildeFullEqual;": "\u2245", + "TildeTilde;": "\u2248", + "Topf;": "\u{01d54b}", + "TripleDot;": "\u20db", + "Tscr;": "\u{01d4af}", + "Tstrok;": "\u0166", + "Uacute": "\xda", + "Uacute;": "\xda", + "Uarr;": "\u219f", + "Uarrocir;": "\u2949", + "Ubrcy;": "\u040e", + "Ubreve;": "\u016c", + "Ucirc": "\xdb", + "Ucirc;": "\xdb", + "Ucy;": "\u0423", + "Udblac;": "\u0170", + "Ufr;": "\u{01d518}", + "Ugrave": "\xd9", + "Ugrave;": "\xd9", + "Umacr;": "\u016a", + "UnderBar;": "_", + "UnderBrace;": "\u23df", + "UnderBracket;": "\u23b5", + "UnderParenthesis;": "\u23dd", + "Union;": "\u22c3", + "UnionPlus;": "\u228e", + "Uogon;": "\u0172", + "Uopf;": "\u{01d54c}", + "UpArrow;": "\u2191", + "UpArrowBar;": "\u2912", + "UpArrowDownArrow;": "\u21c5", + "UpDownArrow;": "\u2195", + "UpEquilibrium;": "\u296e", + "UpTee;": "\u22a5", + "UpTeeArrow;": "\u21a5", + "Uparrow;": "\u21d1", + "Updownarrow;": "\u21d5", + "UpperLeftArrow;": "\u2196", + "UpperRightArrow;": "\u2197", + "Upsi;": "\u03d2", + "Upsilon;": "\u03a5", + "Uring;": "\u016e", + "Uscr;": "\u{01d4b0}", + "Utilde;": "\u0168", + "Uuml": "\xdc", + "Uuml;": "\xdc", + "VDash;": "\u22ab", + "Vbar;": "\u2aeb", + "Vcy;": "\u0412", + "Vdash;": "\u22a9", + "Vdashl;": "\u2ae6", + "Vee;": "\u22c1", + "Verbar;": "\u2016", + "Vert;": "\u2016", + "VerticalBar;": "\u2223", + "VerticalLine;": "|", + "VerticalSeparator;": "\u2758", + "VerticalTilde;": "\u2240", + "VeryThinSpace;": "\u200a", + "Vfr;": "\u{01d519}", + "Vopf;": "\u{01d54d}", + "Vscr;": "\u{01d4b1}", + "Vvdash;": "\u22aa", + "Wcirc;": "\u0174", + "Wedge;": "\u22c0", + "Wfr;": "\u{01d51a}", + "Wopf;": "\u{01d54e}", + "Wscr;": "\u{01d4b2}", + "Xfr;": "\u{01d51b}", + "Xi;": "\u039e", + "Xopf;": "\u{01d54f}", + "Xscr;": "\u{01d4b3}", + "YAcy;": "\u042f", + "YIcy;": "\u0407", + "YUcy;": "\u042e", + "Yacute": "\xdd", + "Yacute;": "\xdd", + "Ycirc;": "\u0176", + "Ycy;": "\u042b", + "Yfr;": "\u{01d51c}", + "Yopf;": "\u{01d550}", + "Yscr;": "\u{01d4b4}", + "Yuml;": "\u0178", + "ZHcy;": "\u0416", + "Zacute;": "\u0179", + "Zcaron;": "\u017d", + "Zcy;": "\u0417", + "Zdot;": "\u017b", + "ZeroWidthSpace;": "\u200b", + "Zeta;": "\u0396", + "Zfr;": "\u2128", + "Zopf;": "\u2124", + "Zscr;": "\u{01d4b5}", + "aacute": "\xe1", + "aacute;": "\xe1", + "abreve;": "\u0103", + "ac;": "\u223e", + "acE;": "\u223e\u0333", + "acd;": "\u223f", + "acirc": "\xe2", + "acirc;": "\xe2", + "acute": "\xb4", + "acute;": "\xb4", + "acy;": "\u0430", + "aelig": "\xe6", + "aelig;": "\xe6", + "af;": "\u2061", + "afr;": "\u{01d51e}", + "agrave": "\xe0", + "agrave;": "\xe0", + "alefsym;": "\u2135", + "aleph;": "\u2135", + "alpha;": "\u03b1", + "amacr;": "\u0101", + "amalg;": "\u2a3f", + "amp": "&", + "amp;": "&", + "and;": "\u2227", + "andand;": "\u2a55", + "andd;": "\u2a5c", + "andslope;": "\u2a58", + "andv;": "\u2a5a", + "ang;": "\u2220", + "ange;": "\u29a4", + "angle;": "\u2220", + "angmsd;": "\u2221", + "angmsdaa;": "\u29a8", + "angmsdab;": "\u29a9", + "angmsdac;": "\u29aa", + "angmsdad;": "\u29ab", + "angmsdae;": "\u29ac", + "angmsdaf;": "\u29ad", + "angmsdag;": "\u29ae", + "angmsdah;": "\u29af", + "angrt;": "\u221f", + "angrtvb;": "\u22be", + "angrtvbd;": "\u299d", + "angsph;": "\u2222", + "angst;": "\xc5", + "angzarr;": "\u237c", + "aogon;": "\u0105", + "aopf;": "\u{01d552}", + "ap;": "\u2248", + "apE;": "\u2a70", + "apacir;": "\u2a6f", + "ape;": "\u224a", + "apid;": "\u224b", + "apos;": "'", + "approx;": "\u2248", + "approxeq;": "\u224a", + "aring": "\xe5", + "aring;": "\xe5", + "ascr;": "\u{01d4b6}", + "ast;": "*", + "asymp;": "\u2248", + "asympeq;": "\u224d", + "atilde": "\xe3", + "atilde;": "\xe3", + "auml": "\xe4", + "auml;": "\xe4", + "awconint;": "\u2233", + "awint;": "\u2a11", + "bNot;": "\u2aed", + "backcong;": "\u224c", + "backepsilon;": "\u03f6", + "backprime;": "\u2035", + "backsim;": "\u223d", + "backsimeq;": "\u22cd", + "barvee;": "\u22bd", + "barwed;": "\u2305", + "barwedge;": "\u2305", + "bbrk;": "\u23b5", + "bbrktbrk;": "\u23b6", + "bcong;": "\u224c", + "bcy;": "\u0431", + "bdquo;": "\u201e", + "becaus;": "\u2235", + "because;": "\u2235", + "bemptyv;": "\u29b0", + "bepsi;": "\u03f6", + "bernou;": "\u212c", + "beta;": "\u03b2", + "beth;": "\u2136", + "between;": "\u226c", + "bfr;": "\u{01d51f}", + "bigcap;": "\u22c2", + "bigcirc;": "\u25ef", + "bigcup;": "\u22c3", + "bigodot;": "\u2a00", + "bigoplus;": "\u2a01", + "bigotimes;": "\u2a02", + "bigsqcup;": "\u2a06", + "bigstar;": "\u2605", + "bigtriangledown;": "\u25bd", + "bigtriangleup;": "\u25b3", + "biguplus;": "\u2a04", + "bigvee;": "\u22c1", + "bigwedge;": "\u22c0", + "bkarow;": "\u290d", + "blacklozenge;": "\u29eb", + "blacksquare;": "\u25aa", + "blacktriangle;": "\u25b4", + "blacktriangledown;": "\u25be", + "blacktriangleleft;": "\u25c2", + "blacktriangleright;": "\u25b8", + "blank;": "\u2423", + "blk12;": "\u2592", + "blk14;": "\u2591", + "blk34;": "\u2593", + "block;": "\u2588", + "bne;": "=\u20e5", + "bnequiv;": "\u2261\u20e5", + "bnot;": "\u2310", + "bopf;": "\u{01d553}", + "bot;": "\u22a5", + "bottom;": "\u22a5", + "bowtie;": "\u22c8", + "boxDL;": "\u2557", + "boxDR;": "\u2554", + "boxDl;": "\u2556", + "boxDr;": "\u2553", + "boxH;": "\u2550", + "boxHD;": "\u2566", + "boxHU;": "\u2569", + "boxHd;": "\u2564", + "boxHu;": "\u2567", + "boxUL;": "\u255d", + "boxUR;": "\u255a", + "boxUl;": "\u255c", + "boxUr;": "\u2559", + "boxV;": "\u2551", + "boxVH;": "\u256c", + "boxVL;": "\u2563", + "boxVR;": "\u2560", + "boxVh;": "\u256b", + "boxVl;": "\u2562", + "boxVr;": "\u255f", + "boxbox;": "\u29c9", + "boxdL;": "\u2555", + "boxdR;": "\u2552", + "boxdl;": "\u2510", + "boxdr;": "\u250c", + "boxh;": "\u2500", + "boxhD;": "\u2565", + "boxhU;": "\u2568", + "boxhd;": "\u252c", + "boxhu;": "\u2534", + "boxminus;": "\u229f", + "boxplus;": "\u229e", + "boxtimes;": "\u22a0", + "boxuL;": "\u255b", + "boxuR;": "\u2558", + "boxul;": "\u2518", + "boxur;": "\u2514", + "boxv;": "\u2502", + "boxvH;": "\u256a", + "boxvL;": "\u2561", + "boxvR;": "\u255e", + "boxvh;": "\u253c", + "boxvl;": "\u2524", + "boxvr;": "\u251c", + "bprime;": "\u2035", + "breve;": "\u02d8", + "brvbar": "\xa6", + "brvbar;": "\xa6", + "bscr;": "\u{01d4b7}", + "bsemi;": "\u204f", + "bsim;": "\u223d", + "bsime;": "\u22cd", + "bsol;": "\\", + "bsolb;": "\u29c5", + "bsolhsub;": "\u27c8", + "bull;": "\u2022", + "bullet;": "\u2022", + "bump;": "\u224e", + "bumpE;": "\u2aae", + "bumpe;": "\u224f", + "bumpeq;": "\u224f", + "cacute;": "\u0107", + "cap;": "\u2229", + "capand;": "\u2a44", + "capbrcup;": "\u2a49", + "capcap;": "\u2a4b", + "capcup;": "\u2a47", + "capdot;": "\u2a40", + "caps;": "\u2229\ufe00", + "caret;": "\u2041", + "caron;": "\u02c7", + "ccaps;": "\u2a4d", + "ccaron;": "\u010d", + "ccedil": "\xe7", + "ccedil;": "\xe7", + "ccirc;": "\u0109", + "ccups;": "\u2a4c", + "ccupssm;": "\u2a50", + "cdot;": "\u010b", + "cedil": "\xb8", + "cedil;": "\xb8", + "cemptyv;": "\u29b2", + "cent": "\xa2", + "cent;": "\xa2", + "centerdot;": "\xb7", + "cfr;": "\u{01d520}", + "chcy;": "\u0447", + "check;": "\u2713", + "checkmark;": "\u2713", + "chi;": "\u03c7", + "cir;": "\u25cb", + "cirE;": "\u29c3", + "circ;": "\u02c6", + "circeq;": "\u2257", + "circlearrowleft;": "\u21ba", + "circlearrowright;": "\u21bb", + "circledR;": "\xae", + "circledS;": "\u24c8", + "circledast;": "\u229b", + "circledcirc;": "\u229a", + "circleddash;": "\u229d", + "cire;": "\u2257", + "cirfnint;": "\u2a10", + "cirmid;": "\u2aef", + "cirscir;": "\u29c2", + "clubs;": "\u2663", + "clubsuit;": "\u2663", + "colon;": ":", + "colone;": "\u2254", + "coloneq;": "\u2254", + "comma;": ",", + "commat;": "@", + "comp;": "\u2201", + "compfn;": "\u2218", + "complement;": "\u2201", + "complexes;": "\u2102", + "cong;": "\u2245", + "congdot;": "\u2a6d", + "conint;": "\u222e", + "copf;": "\u{01d554}", + "coprod;": "\u2210", + "copy": "\xa9", + "copy;": "\xa9", + "copysr;": "\u2117", + "crarr;": "\u21b5", + "cross;": "\u2717", + "cscr;": "\u{01d4b8}", + "csub;": "\u2acf", + "csube;": "\u2ad1", + "csup;": "\u2ad0", + "csupe;": "\u2ad2", + "ctdot;": "\u22ef", + "cudarrl;": "\u2938", + "cudarrr;": "\u2935", + "cuepr;": "\u22de", + "cuesc;": "\u22df", + "cularr;": "\u21b6", + "cularrp;": "\u293d", + "cup;": "\u222a", + "cupbrcap;": "\u2a48", + "cupcap;": "\u2a46", + "cupcup;": "\u2a4a", + "cupdot;": "\u228d", + "cupor;": "\u2a45", + "cups;": "\u222a\ufe00", + "curarr;": "\u21b7", + "curarrm;": "\u293c", + "curlyeqprec;": "\u22de", + "curlyeqsucc;": "\u22df", + "curlyvee;": "\u22ce", + "curlywedge;": "\u22cf", + "curren": "\xa4", + "curren;": "\xa4", + "curvearrowleft;": "\u21b6", + "curvearrowright;": "\u21b7", + "cuvee;": "\u22ce", + "cuwed;": "\u22cf", + "cwconint;": "\u2232", + "cwint;": "\u2231", + "cylcty;": "\u232d", + "dArr;": "\u21d3", + "dHar;": "\u2965", + "dagger;": "\u2020", + "daleth;": "\u2138", + "darr;": "\u2193", + "dash;": "\u2010", + "dashv;": "\u22a3", + "dbkarow;": "\u290f", + "dblac;": "\u02dd", + "dcaron;": "\u010f", + "dcy;": "\u0434", + "dd;": "\u2146", + "ddagger;": "\u2021", + "ddarr;": "\u21ca", + "ddotseq;": "\u2a77", + "deg": "\xb0", + "deg;": "\xb0", + "delta;": "\u03b4", + "demptyv;": "\u29b1", + "dfisht;": "\u297f", + "dfr;": "\u{01d521}", + "dharl;": "\u21c3", + "dharr;": "\u21c2", + "diam;": "\u22c4", + "diamond;": "\u22c4", + "diamondsuit;": "\u2666", + "diams;": "\u2666", + "die;": "\xa8", + "digamma;": "\u03dd", + "disin;": "\u22f2", + "div;": "\xf7", + "divide": "\xf7", + "divide;": "\xf7", + "divideontimes;": "\u22c7", + "divonx;": "\u22c7", + "djcy;": "\u0452", + "dlcorn;": "\u231e", + "dlcrop;": "\u230d", + "dollar;": "\$", + "dopf;": "\u{01d555}", + "dot;": "\u02d9", + "doteq;": "\u2250", + "doteqdot;": "\u2251", + "dotminus;": "\u2238", + "dotplus;": "\u2214", + "dotsquare;": "\u22a1", + "doublebarwedge;": "\u2306", + "downarrow;": "\u2193", + "downdownarrows;": "\u21ca", + "downharpoonleft;": "\u21c3", + "downharpoonright;": "\u21c2", + "drbkarow;": "\u2910", + "drcorn;": "\u231f", + "drcrop;": "\u230c", + "dscr;": "\u{01d4b9}", + "dscy;": "\u0455", + "dsol;": "\u29f6", + "dstrok;": "\u0111", + "dtdot;": "\u22f1", + "dtri;": "\u25bf", + "dtrif;": "\u25be", + "duarr;": "\u21f5", + "duhar;": "\u296f", + "dwangle;": "\u29a6", + "dzcy;": "\u045f", + "dzigrarr;": "\u27ff", + "eDDot;": "\u2a77", + "eDot;": "\u2251", + "eacute": "\xe9", + "eacute;": "\xe9", + "easter;": "\u2a6e", + "ecaron;": "\u011b", + "ecir;": "\u2256", + "ecirc": "\xea", + "ecirc;": "\xea", + "ecolon;": "\u2255", + "ecy;": "\u044d", + "edot;": "\u0117", + "ee;": "\u2147", + "efDot;": "\u2252", + "efr;": "\u{01d522}", + "eg;": "\u2a9a", + "egrave": "\xe8", + "egrave;": "\xe8", + "egs;": "\u2a96", + "egsdot;": "\u2a98", + "el;": "\u2a99", + "elinters;": "\u23e7", + "ell;": "\u2113", + "els;": "\u2a95", + "elsdot;": "\u2a97", + "emacr;": "\u0113", + "empty;": "\u2205", + "emptyset;": "\u2205", + "emptyv;": "\u2205", + "emsp13;": "\u2004", + "emsp14;": "\u2005", + "emsp;": "\u2003", + "eng;": "\u014b", + "ensp;": "\u2002", + "eogon;": "\u0119", + "eopf;": "\u{01d556}", + "epar;": "\u22d5", + "eparsl;": "\u29e3", + "eplus;": "\u2a71", + "epsi;": "\u03b5", + "epsilon;": "\u03b5", + "epsiv;": "\u03f5", + "eqcirc;": "\u2256", + "eqcolon;": "\u2255", + "eqsim;": "\u2242", + "eqslantgtr;": "\u2a96", + "eqslantless;": "\u2a95", + "equals;": "=", + "equest;": "\u225f", + "equiv;": "\u2261", + "equivDD;": "\u2a78", + "eqvparsl;": "\u29e5", + "erDot;": "\u2253", + "erarr;": "\u2971", + "escr;": "\u212f", + "esdot;": "\u2250", + "esim;": "\u2242", + "eta;": "\u03b7", + "eth": "\xf0", + "eth;": "\xf0", + "euml": "\xeb", + "euml;": "\xeb", + "euro;": "\u20ac", + "excl;": "!", + "exist;": "\u2203", + "expectation;": "\u2130", + "exponentiale;": "\u2147", + "fallingdotseq;": "\u2252", + "fcy;": "\u0444", + "female;": "\u2640", + "ffilig;": "\ufb03", + "fflig;": "\ufb00", + "ffllig;": "\ufb04", + "ffr;": "\u{01d523}", + "filig;": "\ufb01", + "fjlig;": "fj", + "flat;": "\u266d", + "fllig;": "\ufb02", + "fltns;": "\u25b1", + "fnof;": "\u0192", + "fopf;": "\u{01d557}", + "forall;": "\u2200", + "fork;": "\u22d4", + "forkv;": "\u2ad9", + "fpartint;": "\u2a0d", + "frac12": "\xbd", + "frac12;": "\xbd", + "frac13;": "\u2153", + "frac14": "\xbc", + "frac14;": "\xbc", + "frac15;": "\u2155", + "frac16;": "\u2159", + "frac18;": "\u215b", + "frac23;": "\u2154", + "frac25;": "\u2156", + "frac34": "\xbe", + "frac34;": "\xbe", + "frac35;": "\u2157", + "frac38;": "\u215c", + "frac45;": "\u2158", + "frac56;": "\u215a", + "frac58;": "\u215d", + "frac78;": "\u215e", + "frasl;": "\u2044", + "frown;": "\u2322", + "fscr;": "\u{01d4bb}", + "gE;": "\u2267", + "gEl;": "\u2a8c", + "gacute;": "\u01f5", + "gamma;": "\u03b3", + "gammad;": "\u03dd", + "gap;": "\u2a86", + "gbreve;": "\u011f", + "gcirc;": "\u011d", + "gcy;": "\u0433", + "gdot;": "\u0121", + "ge;": "\u2265", + "gel;": "\u22db", + "geq;": "\u2265", + "geqq;": "\u2267", + "geqslant;": "\u2a7e", + "ges;": "\u2a7e", + "gescc;": "\u2aa9", + "gesdot;": "\u2a80", + "gesdoto;": "\u2a82", + "gesdotol;": "\u2a84", + "gesl;": "\u22db\ufe00", + "gesles;": "\u2a94", + "gfr;": "\u{01d524}", + "gg;": "\u226b", + "ggg;": "\u22d9", + "gimel;": "\u2137", + "gjcy;": "\u0453", + "gl;": "\u2277", + "glE;": "\u2a92", + "gla;": "\u2aa5", + "glj;": "\u2aa4", + "gnE;": "\u2269", + "gnap;": "\u2a8a", + "gnapprox;": "\u2a8a", + "gne;": "\u2a88", + "gneq;": "\u2a88", + "gneqq;": "\u2269", + "gnsim;": "\u22e7", + "gopf;": "\u{01d558}", + "grave;": "`", + "gscr;": "\u210a", + "gsim;": "\u2273", + "gsime;": "\u2a8e", + "gsiml;": "\u2a90", + "gt": ">", + "gt;": ">", + "gtcc;": "\u2aa7", + "gtcir;": "\u2a7a", + "gtdot;": "\u22d7", + "gtlPar;": "\u2995", + "gtquest;": "\u2a7c", + "gtrapprox;": "\u2a86", + "gtrarr;": "\u2978", + "gtrdot;": "\u22d7", + "gtreqless;": "\u22db", + "gtreqqless;": "\u2a8c", + "gtrless;": "\u2277", + "gtrsim;": "\u2273", + "gvertneqq;": "\u2269\ufe00", + "gvnE;": "\u2269\ufe00", + "hArr;": "\u21d4", + "hairsp;": "\u200a", + "half;": "\xbd", + "hamilt;": "\u210b", + "hardcy;": "\u044a", + "harr;": "\u2194", + "harrcir;": "\u2948", + "harrw;": "\u21ad", + "hbar;": "\u210f", + "hcirc;": "\u0125", + "hearts;": "\u2665", + "heartsuit;": "\u2665", + "hellip;": "\u2026", + "hercon;": "\u22b9", + "hfr;": "\u{01d525}", + "hksearow;": "\u2925", + "hkswarow;": "\u2926", + "hoarr;": "\u21ff", + "homtht;": "\u223b", + "hookleftarrow;": "\u21a9", + "hookrightarrow;": "\u21aa", + "hopf;": "\u{01d559}", + "horbar;": "\u2015", + "hscr;": "\u{01d4bd}", + "hslash;": "\u210f", + "hstrok;": "\u0127", + "hybull;": "\u2043", + "hyphen;": "\u2010", + "iacute": "\xed", + "iacute;": "\xed", + "ic;": "\u2063", + "icirc": "\xee", + "icirc;": "\xee", + "icy;": "\u0438", + "iecy;": "\u0435", + "iexcl": "\xa1", + "iexcl;": "\xa1", + "iff;": "\u21d4", + "ifr;": "\u{01d526}", + "igrave": "\xec", + "igrave;": "\xec", + "ii;": "\u2148", + "iiiint;": "\u2a0c", + "iiint;": "\u222d", + "iinfin;": "\u29dc", + "iiota;": "\u2129", + "ijlig;": "\u0133", + "imacr;": "\u012b", + "image;": "\u2111", + "imagline;": "\u2110", + "imagpart;": "\u2111", + "imath;": "\u0131", + "imof;": "\u22b7", + "imped;": "\u01b5", + "in;": "\u2208", + "incare;": "\u2105", + "infin;": "\u221e", + "infintie;": "\u29dd", + "inodot;": "\u0131", + "int;": "\u222b", + "intcal;": "\u22ba", + "integers;": "\u2124", + "intercal;": "\u22ba", + "intlarhk;": "\u2a17", + "intprod;": "\u2a3c", + "iocy;": "\u0451", + "iogon;": "\u012f", + "iopf;": "\u{01d55a}", + "iota;": "\u03b9", + "iprod;": "\u2a3c", + "iquest": "\xbf", + "iquest;": "\xbf", + "iscr;": "\u{01d4be}", + "isin;": "\u2208", + "isinE;": "\u22f9", + "isindot;": "\u22f5", + "isins;": "\u22f4", + "isinsv;": "\u22f3", + "isinv;": "\u2208", + "it;": "\u2062", + "itilde;": "\u0129", + "iukcy;": "\u0456", + "iuml": "\xef", + "iuml;": "\xef", + "jcirc;": "\u0135", + "jcy;": "\u0439", + "jfr;": "\u{01d527}", + "jmath;": "\u0237", + "jopf;": "\u{01d55b}", + "jscr;": "\u{01d4bf}", + "jsercy;": "\u0458", + "jukcy;": "\u0454", + "kappa;": "\u03ba", + "kappav;": "\u03f0", + "kcedil;": "\u0137", + "kcy;": "\u043a", + "kfr;": "\u{01d528}", + "kgreen;": "\u0138", + "khcy;": "\u0445", + "kjcy;": "\u045c", + "kopf;": "\u{01d55c}", + "kscr;": "\u{01d4c0}", + "lAarr;": "\u21da", + "lArr;": "\u21d0", + "lAtail;": "\u291b", + "lBarr;": "\u290e", + "lE;": "\u2266", + "lEg;": "\u2a8b", + "lHar;": "\u2962", + "lacute;": "\u013a", + "laemptyv;": "\u29b4", + "lagran;": "\u2112", + "lambda;": "\u03bb", + "lang;": "\u27e8", + "langd;": "\u2991", + "langle;": "\u27e8", + "lap;": "\u2a85", + "laquo": "\xab", + "laquo;": "\xab", + "larr;": "\u2190", + "larrb;": "\u21e4", + "larrbfs;": "\u291f", + "larrfs;": "\u291d", + "larrhk;": "\u21a9", + "larrlp;": "\u21ab", + "larrpl;": "\u2939", + "larrsim;": "\u2973", + "larrtl;": "\u21a2", + "lat;": "\u2aab", + "latail;": "\u2919", + "late;": "\u2aad", + "lates;": "\u2aad\ufe00", + "lbarr;": "\u290c", + "lbbrk;": "\u2772", + "lbrace;": "{", + "lbrack;": "[", + "lbrke;": "\u298b", + "lbrksld;": "\u298f", + "lbrkslu;": "\u298d", + "lcaron;": "\u013e", + "lcedil;": "\u013c", + "lceil;": "\u2308", + "lcub;": "{", + "lcy;": "\u043b", + "ldca;": "\u2936", + "ldquo;": "\u201c", + "ldquor;": "\u201e", + "ldrdhar;": "\u2967", + "ldrushar;": "\u294b", + "ldsh;": "\u21b2", + "le;": "\u2264", + "leftarrow;": "\u2190", + "leftarrowtail;": "\u21a2", + "leftharpoondown;": "\u21bd", + "leftharpoonup;": "\u21bc", + "leftleftarrows;": "\u21c7", + "leftrightarrow;": "\u2194", + "leftrightarrows;": "\u21c6", + "leftrightharpoons;": "\u21cb", + "leftrightsquigarrow;": "\u21ad", + "leftthreetimes;": "\u22cb", + "leg;": "\u22da", + "leq;": "\u2264", + "leqq;": "\u2266", + "leqslant;": "\u2a7d", + "les;": "\u2a7d", + "lescc;": "\u2aa8", + "lesdot;": "\u2a7f", + "lesdoto;": "\u2a81", + "lesdotor;": "\u2a83", + "lesg;": "\u22da\ufe00", + "lesges;": "\u2a93", + "lessapprox;": "\u2a85", + "lessdot;": "\u22d6", + "lesseqgtr;": "\u22da", + "lesseqqgtr;": "\u2a8b", + "lessgtr;": "\u2276", + "lesssim;": "\u2272", + "lfisht;": "\u297c", + "lfloor;": "\u230a", + "lfr;": "\u{01d529}", + "lg;": "\u2276", + "lgE;": "\u2a91", + "lhard;": "\u21bd", + "lharu;": "\u21bc", + "lharul;": "\u296a", + "lhblk;": "\u2584", + "ljcy;": "\u0459", + "ll;": "\u226a", + "llarr;": "\u21c7", + "llcorner;": "\u231e", + "llhard;": "\u296b", + "lltri;": "\u25fa", + "lmidot;": "\u0140", + "lmoust;": "\u23b0", + "lmoustache;": "\u23b0", + "lnE;": "\u2268", + "lnap;": "\u2a89", + "lnapprox;": "\u2a89", + "lne;": "\u2a87", + "lneq;": "\u2a87", + "lneqq;": "\u2268", + "lnsim;": "\u22e6", + "loang;": "\u27ec", + "loarr;": "\u21fd", + "lobrk;": "\u27e6", + "longleftarrow;": "\u27f5", + "longleftrightarrow;": "\u27f7", + "longmapsto;": "\u27fc", + "longrightarrow;": "\u27f6", + "looparrowleft;": "\u21ab", + "looparrowright;": "\u21ac", + "lopar;": "\u2985", + "lopf;": "\u{01d55d}", + "loplus;": "\u2a2d", + "lotimes;": "\u2a34", + "lowast;": "\u2217", + "lowbar;": "_", + "loz;": "\u25ca", + "lozenge;": "\u25ca", + "lozf;": "\u29eb", + "lpar;": "(", + "lparlt;": "\u2993", + "lrarr;": "\u21c6", + "lrcorner;": "\u231f", + "lrhar;": "\u21cb", + "lrhard;": "\u296d", + "lrm;": "\u200e", + "lrtri;": "\u22bf", + "lsaquo;": "\u2039", + "lscr;": "\u{01d4c1}", + "lsh;": "\u21b0", + "lsim;": "\u2272", + "lsime;": "\u2a8d", + "lsimg;": "\u2a8f", + "lsqb;": "[", + "lsquo;": "\u2018", + "lsquor;": "\u201a", + "lstrok;": "\u0142", + "lt": "<", + "lt;": "<", + "ltcc;": "\u2aa6", + "ltcir;": "\u2a79", + "ltdot;": "\u22d6", + "lthree;": "\u22cb", + "ltimes;": "\u22c9", + "ltlarr;": "\u2976", + "ltquest;": "\u2a7b", + "ltrPar;": "\u2996", + "ltri;": "\u25c3", + "ltrie;": "\u22b4", + "ltrif;": "\u25c2", + "lurdshar;": "\u294a", + "luruhar;": "\u2966", + "lvertneqq;": "\u2268\ufe00", + "lvnE;": "\u2268\ufe00", + "mDDot;": "\u223a", + "macr": "\xaf", + "macr;": "\xaf", + "male;": "\u2642", + "malt;": "\u2720", + "maltese;": "\u2720", + "map;": "\u21a6", + "mapsto;": "\u21a6", + "mapstodown;": "\u21a7", + "mapstoleft;": "\u21a4", + "mapstoup;": "\u21a5", + "marker;": "\u25ae", + "mcomma;": "\u2a29", + "mcy;": "\u043c", + "mdash;": "\u2014", + "measuredangle;": "\u2221", + "mfr;": "\u{01d52a}", + "mho;": "\u2127", + "micro": "\xb5", + "micro;": "\xb5", + "mid;": "\u2223", + "midast;": "*", + "midcir;": "\u2af0", + "middot": "\xb7", + "middot;": "\xb7", + "minus;": "\u2212", + "minusb;": "\u229f", + "minusd;": "\u2238", + "minusdu;": "\u2a2a", + "mlcp;": "\u2adb", + "mldr;": "\u2026", + "mnplus;": "\u2213", + "models;": "\u22a7", + "mopf;": "\u{01d55e}", + "mp;": "\u2213", + "mscr;": "\u{01d4c2}", + "mstpos;": "\u223e", + "mu;": "\u03bc", + "multimap;": "\u22b8", + "mumap;": "\u22b8", + "nGg;": "\u22d9\u0338", + "nGt;": "\u226b\u20d2", + "nGtv;": "\u226b\u0338", + "nLeftarrow;": "\u21cd", + "nLeftrightarrow;": "\u21ce", + "nLl;": "\u22d8\u0338", + "nLt;": "\u226a\u20d2", + "nLtv;": "\u226a\u0338", + "nRightarrow;": "\u21cf", + "nVDash;": "\u22af", + "nVdash;": "\u22ae", + "nabla;": "\u2207", + "nacute;": "\u0144", + "nang;": "\u2220\u20d2", + "nap;": "\u2249", + "napE;": "\u2a70\u0338", + "napid;": "\u224b\u0338", + "napos;": "\u0149", + "napprox;": "\u2249", + "natur;": "\u266e", + "natural;": "\u266e", + "naturals;": "\u2115", + "nbsp": "\xa0", + "nbsp;": "\xa0", + "nbump;": "\u224e\u0338", + "nbumpe;": "\u224f\u0338", + "ncap;": "\u2a43", + "ncaron;": "\u0148", + "ncedil;": "\u0146", + "ncong;": "\u2247", + "ncongdot;": "\u2a6d\u0338", + "ncup;": "\u2a42", + "ncy;": "\u043d", + "ndash;": "\u2013", + "ne;": "\u2260", + "neArr;": "\u21d7", + "nearhk;": "\u2924", + "nearr;": "\u2197", + "nearrow;": "\u2197", + "nedot;": "\u2250\u0338", + "nequiv;": "\u2262", + "nesear;": "\u2928", + "nesim;": "\u2242\u0338", + "nexist;": "\u2204", + "nexists;": "\u2204", + "nfr;": "\u{01d52b}", + "ngE;": "\u2267\u0338", + "nge;": "\u2271", + "ngeq;": "\u2271", + "ngeqq;": "\u2267\u0338", + "ngeqslant;": "\u2a7e\u0338", + "nges;": "\u2a7e\u0338", + "ngsim;": "\u2275", + "ngt;": "\u226f", + "ngtr;": "\u226f", + "nhArr;": "\u21ce", + "nharr;": "\u21ae", + "nhpar;": "\u2af2", + "ni;": "\u220b", + "nis;": "\u22fc", + "nisd;": "\u22fa", + "niv;": "\u220b", + "njcy;": "\u045a", + "nlArr;": "\u21cd", + "nlE;": "\u2266\u0338", + "nlarr;": "\u219a", + "nldr;": "\u2025", + "nle;": "\u2270", + "nleftarrow;": "\u219a", + "nleftrightarrow;": "\u21ae", + "nleq;": "\u2270", + "nleqq;": "\u2266\u0338", + "nleqslant;": "\u2a7d\u0338", + "nles;": "\u2a7d\u0338", + "nless;": "\u226e", + "nlsim;": "\u2274", + "nlt;": "\u226e", + "nltri;": "\u22ea", + "nltrie;": "\u22ec", + "nmid;": "\u2224", + "nopf;": "\u{01d55f}", + "not": "\xac", + "not;": "\xac", + "notin;": "\u2209", + "notinE;": "\u22f9\u0338", + "notindot;": "\u22f5\u0338", + "notinva;": "\u2209", + "notinvb;": "\u22f7", + "notinvc;": "\u22f6", + "notni;": "\u220c", + "notniva;": "\u220c", + "notnivb;": "\u22fe", + "notnivc;": "\u22fd", + "npar;": "\u2226", + "nparallel;": "\u2226", + "nparsl;": "\u2afd\u20e5", + "npart;": "\u2202\u0338", + "npolint;": "\u2a14", + "npr;": "\u2280", + "nprcue;": "\u22e0", + "npre;": "\u2aaf\u0338", + "nprec;": "\u2280", + "npreceq;": "\u2aaf\u0338", + "nrArr;": "\u21cf", + "nrarr;": "\u219b", + "nrarrc;": "\u2933\u0338", + "nrarrw;": "\u219d\u0338", + "nrightarrow;": "\u219b", + "nrtri;": "\u22eb", + "nrtrie;": "\u22ed", + "nsc;": "\u2281", + "nsccue;": "\u22e1", + "nsce;": "\u2ab0\u0338", + "nscr;": "\u{01d4c3}", + "nshortmid;": "\u2224", + "nshortparallel;": "\u2226", + "nsim;": "\u2241", + "nsime;": "\u2244", + "nsimeq;": "\u2244", + "nsmid;": "\u2224", + "nspar;": "\u2226", + "nsqsube;": "\u22e2", + "nsqsupe;": "\u22e3", + "nsub;": "\u2284", + "nsubE;": "\u2ac5\u0338", + "nsube;": "\u2288", + "nsubset;": "\u2282\u20d2", + "nsubseteq;": "\u2288", + "nsubseteqq;": "\u2ac5\u0338", + "nsucc;": "\u2281", + "nsucceq;": "\u2ab0\u0338", + "nsup;": "\u2285", + "nsupE;": "\u2ac6\u0338", + "nsupe;": "\u2289", + "nsupset;": "\u2283\u20d2", + "nsupseteq;": "\u2289", + "nsupseteqq;": "\u2ac6\u0338", + "ntgl;": "\u2279", + "ntilde": "\xf1", + "ntilde;": "\xf1", + "ntlg;": "\u2278", + "ntriangleleft;": "\u22ea", + "ntrianglelefteq;": "\u22ec", + "ntriangleright;": "\u22eb", + "ntrianglerighteq;": "\u22ed", + "nu;": "\u03bd", + "num;": "#", + "numero;": "\u2116", + "numsp;": "\u2007", + "nvDash;": "\u22ad", + "nvHarr;": "\u2904", + "nvap;": "\u224d\u20d2", + "nvdash;": "\u22ac", + "nvge;": "\u2265\u20d2", + "nvgt;": ">\u20d2", + "nvinfin;": "\u29de", + "nvlArr;": "\u2902", + "nvle;": "\u2264\u20d2", + "nvlt;": "<\u20d2", + "nvltrie;": "\u22b4\u20d2", + "nvrArr;": "\u2903", + "nvrtrie;": "\u22b5\u20d2", + "nvsim;": "\u223c\u20d2", + "nwArr;": "\u21d6", + "nwarhk;": "\u2923", + "nwarr;": "\u2196", + "nwarrow;": "\u2196", + "nwnear;": "\u2927", + "oS;": "\u24c8", + "oacute": "\xf3", + "oacute;": "\xf3", + "oast;": "\u229b", + "ocir;": "\u229a", + "ocirc": "\xf4", + "ocirc;": "\xf4", + "ocy;": "\u043e", + "odash;": "\u229d", + "odblac;": "\u0151", + "odiv;": "\u2a38", + "odot;": "\u2299", + "odsold;": "\u29bc", + "oelig;": "\u0153", + "ofcir;": "\u29bf", + "ofr;": "\u{01d52c}", + "ogon;": "\u02db", + "ograve": "\xf2", + "ograve;": "\xf2", + "ogt;": "\u29c1", + "ohbar;": "\u29b5", + "ohm;": "\u03a9", + "oint;": "\u222e", + "olarr;": "\u21ba", + "olcir;": "\u29be", + "olcross;": "\u29bb", + "oline;": "\u203e", + "olt;": "\u29c0", + "omacr;": "\u014d", + "omega;": "\u03c9", + "omicron;": "\u03bf", + "omid;": "\u29b6", + "ominus;": "\u2296", + "oopf;": "\u{01d560}", + "opar;": "\u29b7", + "operp;": "\u29b9", + "oplus;": "\u2295", + "or;": "\u2228", + "orarr;": "\u21bb", + "ord;": "\u2a5d", + "order;": "\u2134", + "orderof;": "\u2134", + "ordf": "\xaa", + "ordf;": "\xaa", + "ordm": "\xba", + "ordm;": "\xba", + "origof;": "\u22b6", + "oror;": "\u2a56", + "orslope;": "\u2a57", + "orv;": "\u2a5b", + "oscr;": "\u2134", + "oslash": "\xf8", + "oslash;": "\xf8", + "osol;": "\u2298", + "otilde": "\xf5", + "otilde;": "\xf5", + "otimes;": "\u2297", + "otimesas;": "\u2a36", + "ouml": "\xf6", + "ouml;": "\xf6", + "ovbar;": "\u233d", + "par;": "\u2225", + "para": "\xb6", + "para;": "\xb6", + "parallel;": "\u2225", + "parsim;": "\u2af3", + "parsl;": "\u2afd", + "part;": "\u2202", + "pcy;": "\u043f", + "percnt;": "%", + "period;": ".", + "permil;": "\u2030", + "perp;": "\u22a5", + "pertenk;": "\u2031", + "pfr;": "\u{01d52d}", + "phi;": "\u03c6", + "phiv;": "\u03d5", + "phmmat;": "\u2133", + "phone;": "\u260e", + "pi;": "\u03c0", + "pitchfork;": "\u22d4", + "piv;": "\u03d6", + "planck;": "\u210f", + "planckh;": "\u210e", + "plankv;": "\u210f", + "plus;": "+", + "plusacir;": "\u2a23", + "plusb;": "\u229e", + "pluscir;": "\u2a22", + "plusdo;": "\u2214", + "plusdu;": "\u2a25", + "pluse;": "\u2a72", + "plusmn": "\xb1", + "plusmn;": "\xb1", + "plussim;": "\u2a26", + "plustwo;": "\u2a27", + "pm;": "\xb1", + "pointint;": "\u2a15", + "popf;": "\u{01d561}", + "pound": "\xa3", + "pound;": "\xa3", + "pr;": "\u227a", + "prE;": "\u2ab3", + "prap;": "\u2ab7", + "prcue;": "\u227c", + "pre;": "\u2aaf", + "prec;": "\u227a", + "precapprox;": "\u2ab7", + "preccurlyeq;": "\u227c", + "preceq;": "\u2aaf", + "precnapprox;": "\u2ab9", + "precneqq;": "\u2ab5", + "precnsim;": "\u22e8", + "precsim;": "\u227e", + "prime;": "\u2032", + "primes;": "\u2119", + "prnE;": "\u2ab5", + "prnap;": "\u2ab9", + "prnsim;": "\u22e8", + "prod;": "\u220f", + "profalar;": "\u232e", + "profline;": "\u2312", + "profsurf;": "\u2313", + "prop;": "\u221d", + "propto;": "\u221d", + "prsim;": "\u227e", + "prurel;": "\u22b0", + "pscr;": "\u{01d4c5}", + "psi;": "\u03c8", + "puncsp;": "\u2008", + "qfr;": "\u{01d52e}", + "qint;": "\u2a0c", + "qopf;": "\u{01d562}", + "qprime;": "\u2057", + "qscr;": "\u{01d4c6}", + "quaternions;": "\u210d", + "quatint;": "\u2a16", + "quest;": "?", + "questeq;": "\u225f", + "quot": "\"", + "quot;": "\"", + "rAarr;": "\u21db", + "rArr;": "\u21d2", + "rAtail;": "\u291c", + "rBarr;": "\u290f", + "rHar;": "\u2964", + "race;": "\u223d\u0331", + "racute;": "\u0155", + "radic;": "\u221a", + "raemptyv;": "\u29b3", + "rang;": "\u27e9", + "rangd;": "\u2992", + "range;": "\u29a5", + "rangle;": "\u27e9", + "raquo": "\xbb", + "raquo;": "\xbb", + "rarr;": "\u2192", + "rarrap;": "\u2975", + "rarrb;": "\u21e5", + "rarrbfs;": "\u2920", + "rarrc;": "\u2933", + "rarrfs;": "\u291e", + "rarrhk;": "\u21aa", + "rarrlp;": "\u21ac", + "rarrpl;": "\u2945", + "rarrsim;": "\u2974", + "rarrtl;": "\u21a3", + "rarrw;": "\u219d", + "ratail;": "\u291a", + "ratio;": "\u2236", + "rationals;": "\u211a", + "rbarr;": "\u290d", + "rbbrk;": "\u2773", + "rbrace;": "}", + "rbrack;": "]", + "rbrke;": "\u298c", + "rbrksld;": "\u298e", + "rbrkslu;": "\u2990", + "rcaron;": "\u0159", + "rcedil;": "\u0157", + "rceil;": "\u2309", + "rcub;": "}", + "rcy;": "\u0440", + "rdca;": "\u2937", + "rdldhar;": "\u2969", + "rdquo;": "\u201d", + "rdquor;": "\u201d", + "rdsh;": "\u21b3", + "real;": "\u211c", + "realine;": "\u211b", + "realpart;": "\u211c", + "reals;": "\u211d", + "rect;": "\u25ad", + "reg": "\xae", + "reg;": "\xae", + "rfisht;": "\u297d", + "rfloor;": "\u230b", + "rfr;": "\u{01d52f}", + "rhard;": "\u21c1", + "rharu;": "\u21c0", + "rharul;": "\u296c", + "rho;": "\u03c1", + "rhov;": "\u03f1", + "rightarrow;": "\u2192", + "rightarrowtail;": "\u21a3", + "rightharpoondown;": "\u21c1", + "rightharpoonup;": "\u21c0", + "rightleftarrows;": "\u21c4", + "rightleftharpoons;": "\u21cc", + "rightrightarrows;": "\u21c9", + "rightsquigarrow;": "\u219d", + "rightthreetimes;": "\u22cc", + "ring;": "\u02da", + "risingdotseq;": "\u2253", + "rlarr;": "\u21c4", + "rlhar;": "\u21cc", + "rlm;": "\u200f", + "rmoust;": "\u23b1", + "rmoustache;": "\u23b1", + "rnmid;": "\u2aee", + "roang;": "\u27ed", + "roarr;": "\u21fe", + "robrk;": "\u27e7", + "ropar;": "\u2986", + "ropf;": "\u{01d563}", + "roplus;": "\u2a2e", + "rotimes;": "\u2a35", + "rpar;": ")", + "rpargt;": "\u2994", + "rppolint;": "\u2a12", + "rrarr;": "\u21c9", + "rsaquo;": "\u203a", + "rscr;": "\u{01d4c7}", + "rsh;": "\u21b1", + "rsqb;": "]", + "rsquo;": "\u2019", + "rsquor;": "\u2019", + "rthree;": "\u22cc", + "rtimes;": "\u22ca", + "rtri;": "\u25b9", + "rtrie;": "\u22b5", + "rtrif;": "\u25b8", + "rtriltri;": "\u29ce", + "ruluhar;": "\u2968", + "rx;": "\u211e", + "sacute;": "\u015b", + "sbquo;": "\u201a", + "sc;": "\u227b", + "scE;": "\u2ab4", + "scap;": "\u2ab8", + "scaron;": "\u0161", + "sccue;": "\u227d", + "sce;": "\u2ab0", + "scedil;": "\u015f", + "scirc;": "\u015d", + "scnE;": "\u2ab6", + "scnap;": "\u2aba", + "scnsim;": "\u22e9", + "scpolint;": "\u2a13", + "scsim;": "\u227f", + "scy;": "\u0441", + "sdot;": "\u22c5", + "sdotb;": "\u22a1", + "sdote;": "\u2a66", + "seArr;": "\u21d8", + "searhk;": "\u2925", + "searr;": "\u2198", + "searrow;": "\u2198", + "sect": "\xa7", + "sect;": "\xa7", + "semi;": ";", + "seswar;": "\u2929", + "setminus;": "\u2216", + "setmn;": "\u2216", + "sext;": "\u2736", + "sfr;": "\u{01d530}", + "sfrown;": "\u2322", + "sharp;": "\u266f", + "shchcy;": "\u0449", + "shcy;": "\u0448", + "shortmid;": "\u2223", + "shortparallel;": "\u2225", + "shy": "\xad", + "shy;": "\xad", + "sigma;": "\u03c3", + "sigmaf;": "\u03c2", + "sigmav;": "\u03c2", + "sim;": "\u223c", + "simdot;": "\u2a6a", + "sime;": "\u2243", + "simeq;": "\u2243", + "simg;": "\u2a9e", + "simgE;": "\u2aa0", + "siml;": "\u2a9d", + "simlE;": "\u2a9f", + "simne;": "\u2246", + "simplus;": "\u2a24", + "simrarr;": "\u2972", + "slarr;": "\u2190", + "smallsetminus;": "\u2216", + "smashp;": "\u2a33", + "smeparsl;": "\u29e4", + "smid;": "\u2223", + "smile;": "\u2323", + "smt;": "\u2aaa", + "smte;": "\u2aac", + "smtes;": "\u2aac\ufe00", + "softcy;": "\u044c", + "sol;": "/", + "solb;": "\u29c4", + "solbar;": "\u233f", + "sopf;": "\u{01d564}", + "spades;": "\u2660", + "spadesuit;": "\u2660", + "spar;": "\u2225", + "sqcap;": "\u2293", + "sqcaps;": "\u2293\ufe00", + "sqcup;": "\u2294", + "sqcups;": "\u2294\ufe00", + "sqsub;": "\u228f", + "sqsube;": "\u2291", + "sqsubset;": "\u228f", + "sqsubseteq;": "\u2291", + "sqsup;": "\u2290", + "sqsupe;": "\u2292", + "sqsupset;": "\u2290", + "sqsupseteq;": "\u2292", + "squ;": "\u25a1", + "square;": "\u25a1", + "squarf;": "\u25aa", + "squf;": "\u25aa", + "srarr;": "\u2192", + "sscr;": "\u{01d4c8}", + "ssetmn;": "\u2216", + "ssmile;": "\u2323", + "sstarf;": "\u22c6", + "star;": "\u2606", + "starf;": "\u2605", + "straightepsilon;": "\u03f5", + "straightphi;": "\u03d5", + "strns;": "\xaf", + "sub;": "\u2282", + "subE;": "\u2ac5", + "subdot;": "\u2abd", + "sube;": "\u2286", + "subedot;": "\u2ac3", + "submult;": "\u2ac1", + "subnE;": "\u2acb", + "subne;": "\u228a", + "subplus;": "\u2abf", + "subrarr;": "\u2979", + "subset;": "\u2282", + "subseteq;": "\u2286", + "subseteqq;": "\u2ac5", + "subsetneq;": "\u228a", + "subsetneqq;": "\u2acb", + "subsim;": "\u2ac7", + "subsub;": "\u2ad5", + "subsup;": "\u2ad3", + "succ;": "\u227b", + "succapprox;": "\u2ab8", + "succcurlyeq;": "\u227d", + "succeq;": "\u2ab0", + "succnapprox;": "\u2aba", + "succneqq;": "\u2ab6", + "succnsim;": "\u22e9", + "succsim;": "\u227f", + "sum;": "\u2211", + "sung;": "\u266a", + "sup1": "\xb9", + "sup1;": "\xb9", + "sup2": "\xb2", + "sup2;": "\xb2", + "sup3": "\xb3", + "sup3;": "\xb3", + "sup;": "\u2283", + "supE;": "\u2ac6", + "supdot;": "\u2abe", + "supdsub;": "\u2ad8", + "supe;": "\u2287", + "supedot;": "\u2ac4", + "suphsol;": "\u27c9", + "suphsub;": "\u2ad7", + "suplarr;": "\u297b", + "supmult;": "\u2ac2", + "supnE;": "\u2acc", + "supne;": "\u228b", + "supplus;": "\u2ac0", + "supset;": "\u2283", + "supseteq;": "\u2287", + "supseteqq;": "\u2ac6", + "supsetneq;": "\u228b", + "supsetneqq;": "\u2acc", + "supsim;": "\u2ac8", + "supsub;": "\u2ad4", + "supsup;": "\u2ad6", + "swArr;": "\u21d9", + "swarhk;": "\u2926", + "swarr;": "\u2199", + "swarrow;": "\u2199", + "swnwar;": "\u292a", + "szlig": "\xdf", + "szlig;": "\xdf", + "target;": "\u2316", + "tau;": "\u03c4", + "tbrk;": "\u23b4", + "tcaron;": "\u0165", + "tcedil;": "\u0163", + "tcy;": "\u0442", + "tdot;": "\u20db", + "telrec;": "\u2315", + "tfr;": "\u{01d531}", + "there4;": "\u2234", + "therefore;": "\u2234", + "theta;": "\u03b8", + "thetasym;": "\u03d1", + "thetav;": "\u03d1", + "thickapprox;": "\u2248", + "thicksim;": "\u223c", + "thinsp;": "\u2009", + "thkap;": "\u2248", + "thksim;": "\u223c", + "thorn": "\xfe", + "thorn;": "\xfe", + "tilde;": "\u02dc", + "times": "\xd7", + "times;": "\xd7", + "timesb;": "\u22a0", + "timesbar;": "\u2a31", + "timesd;": "\u2a30", + "tint;": "\u222d", + "toea;": "\u2928", + "top;": "\u22a4", + "topbot;": "\u2336", + "topcir;": "\u2af1", + "topf;": "\u{01d565}", + "topfork;": "\u2ada", + "tosa;": "\u2929", + "tprime;": "\u2034", + "trade;": "\u2122", + "triangle;": "\u25b5", + "triangledown;": "\u25bf", + "triangleleft;": "\u25c3", + "trianglelefteq;": "\u22b4", + "triangleq;": "\u225c", + "triangleright;": "\u25b9", + "trianglerighteq;": "\u22b5", + "tridot;": "\u25ec", + "trie;": "\u225c", + "triminus;": "\u2a3a", + "triplus;": "\u2a39", + "trisb;": "\u29cd", + "tritime;": "\u2a3b", + "trpezium;": "\u23e2", + "tscr;": "\u{01d4c9}", + "tscy;": "\u0446", + "tshcy;": "\u045b", + "tstrok;": "\u0167", + "twixt;": "\u226c", + "twoheadleftarrow;": "\u219e", + "twoheadrightarrow;": "\u21a0", + "uArr;": "\u21d1", + "uHar;": "\u2963", + "uacute": "\xfa", + "uacute;": "\xfa", + "uarr;": "\u2191", + "ubrcy;": "\u045e", + "ubreve;": "\u016d", + "ucirc": "\xfb", + "ucirc;": "\xfb", + "ucy;": "\u0443", + "udarr;": "\u21c5", + "udblac;": "\u0171", + "udhar;": "\u296e", + "ufisht;": "\u297e", + "ufr;": "\u{01d532}", + "ugrave": "\xf9", + "ugrave;": "\xf9", + "uharl;": "\u21bf", + "uharr;": "\u21be", + "uhblk;": "\u2580", + "ulcorn;": "\u231c", + "ulcorner;": "\u231c", + "ulcrop;": "\u230f", + "ultri;": "\u25f8", + "umacr;": "\u016b", + "uml": "\xa8", + "uml;": "\xa8", + "uogon;": "\u0173", + "uopf;": "\u{01d566}", + "uparrow;": "\u2191", + "updownarrow;": "\u2195", + "upharpoonleft;": "\u21bf", + "upharpoonright;": "\u21be", + "uplus;": "\u228e", + "upsi;": "\u03c5", + "upsih;": "\u03d2", + "upsilon;": "\u03c5", + "upuparrows;": "\u21c8", + "urcorn;": "\u231d", + "urcorner;": "\u231d", + "urcrop;": "\u230e", + "uring;": "\u016f", + "urtri;": "\u25f9", + "uscr;": "\u{01d4ca}", + "utdot;": "\u22f0", + "utilde;": "\u0169", + "utri;": "\u25b5", + "utrif;": "\u25b4", + "uuarr;": "\u21c8", + "uuml": "\xfc", + "uuml;": "\xfc", + "uwangle;": "\u29a7", + "vArr;": "\u21d5", + "vBar;": "\u2ae8", + "vBarv;": "\u2ae9", + "vDash;": "\u22a8", + "vangrt;": "\u299c", + "varepsilon;": "\u03f5", + "varkappa;": "\u03f0", + "varnothing;": "\u2205", + "varphi;": "\u03d5", + "varpi;": "\u03d6", + "varpropto;": "\u221d", + "varr;": "\u2195", + "varrho;": "\u03f1", + "varsigma;": "\u03c2", + "varsubsetneq;": "\u228a\ufe00", + "varsubsetneqq;": "\u2acb\ufe00", + "varsupsetneq;": "\u228b\ufe00", + "varsupsetneqq;": "\u2acc\ufe00", + "vartheta;": "\u03d1", + "vartriangleleft;": "\u22b2", + "vartriangleright;": "\u22b3", + "vcy;": "\u0432", + "vdash;": "\u22a2", + "vee;": "\u2228", + "veebar;": "\u22bb", + "veeeq;": "\u225a", + "vellip;": "\u22ee", + "verbar;": "|", + "vert;": "|", + "vfr;": "\u{01d533}", + "vltri;": "\u22b2", + "vnsub;": "\u2282\u20d2", + "vnsup;": "\u2283\u20d2", + "vopf;": "\u{01d567}", + "vprop;": "\u221d", + "vrtri;": "\u22b3", + "vscr;": "\u{01d4cb}", + "vsubnE;": "\u2acb\ufe00", + "vsubne;": "\u228a\ufe00", + "vsupnE;": "\u2acc\ufe00", + "vsupne;": "\u228b\ufe00", + "vzigzag;": "\u299a", + "wcirc;": "\u0175", + "wedbar;": "\u2a5f", + "wedge;": "\u2227", + "wedgeq;": "\u2259", + "weierp;": "\u2118", + "wfr;": "\u{01d534}", + "wopf;": "\u{01d568}", + "wp;": "\u2118", + "wr;": "\u2240", + "wreath;": "\u2240", + "wscr;": "\u{01d4cc}", + "xcap;": "\u22c2", + "xcirc;": "\u25ef", + "xcup;": "\u22c3", + "xdtri;": "\u25bd", + "xfr;": "\u{01d535}", + "xhArr;": "\u27fa", + "xharr;": "\u27f7", + "xi;": "\u03be", + "xlArr;": "\u27f8", + "xlarr;": "\u27f5", + "xmap;": "\u27fc", + "xnis;": "\u22fb", + "xodot;": "\u2a00", + "xopf;": "\u{01d569}", + "xoplus;": "\u2a01", + "xotime;": "\u2a02", + "xrArr;": "\u27f9", + "xrarr;": "\u27f6", + "xscr;": "\u{01d4cd}", + "xsqcup;": "\u2a06", + "xuplus;": "\u2a04", + "xutri;": "\u25b3", + "xvee;": "\u22c1", + "xwedge;": "\u22c0", + "yacute": "\xfd", + "yacute;": "\xfd", + "yacy;": "\u044f", + "ycirc;": "\u0177", + "ycy;": "\u044b", + "yen": "\xa5", + "yen;": "\xa5", + "yfr;": "\u{01d536}", + "yicy;": "\u0457", + "yopf;": "\u{01d56a}", + "yscr;": "\u{01d4ce}", + "yucy;": "\u044e", + "yuml": "\xff", + "yuml;": "\xff", + "zacute;": "\u017a", + "zcaron;": "\u017e", + "zcy;": "\u0437", + "zdot;": "\u017c", + "zeetrf;": "\u2128", + "zeta;": "\u03b6", + "zfr;": "\u{01d537}", + "zhcy;": "\u0436", + "zigrarr;": "\u21dd", + "zopf;": "\u{01d56b}", + "zscr;": "\u{01d4cf}", + "zwj;": "\u200d", + "zwnj;": "\u200c", +}; + +Map _replacementCharacters; +Map get replacementCharacters() { + if (_replacementCharacters == null) { + // TODO(jmesserly): fix this when Dart has literal maps with int keys. + var r = new Map(); + r[0x00] = "\uFFFD"; + r[0x0d] = "\u000D"; + r[0x80] = "\u20AC"; + r[0x81] = "\u0081"; + r[0x81] = "\u0081"; + r[0x82] = "\u201A"; + r[0x83] = "\u0192"; + r[0x84] = "\u201E"; + r[0x85] = "\u2026"; + r[0x86] = "\u2020"; + r[0x87] = "\u2021"; + r[0x88] = "\u02C6"; + r[0x89] = "\u2030"; + r[0x8A] = "\u0160"; + r[0x8B] = "\u2039"; + r[0x8C] = "\u0152"; + r[0x8D] = "\u008D"; + r[0x8E] = "\u017D"; + r[0x8F] = "\u008F"; + r[0x90] = "\u0090"; + r[0x91] = "\u2018"; + r[0x92] = "\u2019"; + r[0x93] = "\u201C"; + r[0x94] = "\u201D"; + r[0x95] = "\u2022"; + r[0x96] = "\u2013"; + r[0x97] = "\u2014"; + r[0x98] = "\u02DC"; + r[0x99] = "\u2122"; + r[0x9A] = "\u0161"; + r[0x9B] = "\u203A"; + r[0x9C] = "\u0153"; + r[0x9D] = "\u009D"; + r[0x9E] = "\u017E"; + r[0x9F] = "\u0178"; + _replacementCharacters = r; + } + return _replacementCharacters; +} + +final Map encodings = const { + '437': 'cp437', + '850': 'cp850', + '852': 'cp852', + '855': 'cp855', + '857': 'cp857', + '860': 'cp860', + '861': 'cp861', + '862': 'cp862', + '863': 'cp863', + '865': 'cp865', + '866': 'cp866', + '869': 'cp869', + 'ansix341968': 'ascii', + 'ansix341986': 'ascii', + 'arabic': 'iso8859-6', + 'ascii': 'ascii', + 'asmo708': 'iso8859-6', + 'big5': 'big5', + 'big5hkscs': 'big5hkscs', + 'chinese': 'gbk', + 'cp037': 'cp037', + 'cp1026': 'cp1026', + 'cp154': 'ptcp154', + 'cp367': 'ascii', + 'cp424': 'cp424', + 'cp437': 'cp437', + 'cp500': 'cp500', + 'cp775': 'cp775', + 'cp819': 'windows-1252', + 'cp850': 'cp850', + 'cp852': 'cp852', + 'cp855': 'cp855', + 'cp857': 'cp857', + 'cp860': 'cp860', + 'cp861': 'cp861', + 'cp862': 'cp862', + 'cp863': 'cp863', + 'cp864': 'cp864', + 'cp865': 'cp865', + 'cp866': 'cp866', + 'cp869': 'cp869', + 'cp936': 'gbk', + 'cpgr': 'cp869', + 'cpis': 'cp861', + 'csascii': 'ascii', + 'csbig5': 'big5', + 'cseuckr': 'cp949', + 'cseucpkdfmtjapanese': 'euc_jp', + 'csgb2312': 'gbk', + 'cshproman8': 'hp-roman8', + 'csibm037': 'cp037', + 'csibm1026': 'cp1026', + 'csibm424': 'cp424', + 'csibm500': 'cp500', + 'csibm855': 'cp855', + 'csibm857': 'cp857', + 'csibm860': 'cp860', + 'csibm861': 'cp861', + 'csibm863': 'cp863', + 'csibm864': 'cp864', + 'csibm865': 'cp865', + 'csibm866': 'cp866', + 'csibm869': 'cp869', + 'csiso2022jp': 'iso2022_jp', + 'csiso2022jp2': 'iso2022_jp_2', + 'csiso2022kr': 'iso2022_kr', + 'csiso58gb231280': 'gbk', + 'csisolatin1': 'windows-1252', + 'csisolatin2': 'iso8859-2', + 'csisolatin3': 'iso8859-3', + 'csisolatin4': 'iso8859-4', + 'csisolatin5': 'windows-1254', + 'csisolatin6': 'iso8859-10', + 'csisolatinarabic': 'iso8859-6', + 'csisolatincyrillic': 'iso8859-5', + 'csisolatingreek': 'iso8859-7', + 'csisolatinhebrew': 'iso8859-8', + 'cskoi8r': 'koi8-r', + 'csksc56011987': 'cp949', + 'cspc775baltic': 'cp775', + 'cspc850multilingual': 'cp850', + 'cspc862latinhebrew': 'cp862', + 'cspc8codepage437': 'cp437', + 'cspcp852': 'cp852', + 'csptcp154': 'ptcp154', + 'csshiftjis': 'shift_jis', + 'csunicode11utf7': 'utf-7', + 'cyrillic': 'iso8859-5', + 'cyrillicasian': 'ptcp154', + 'ebcdiccpbe': 'cp500', + 'ebcdiccpca': 'cp037', + 'ebcdiccpch': 'cp500', + 'ebcdiccphe': 'cp424', + 'ebcdiccpnl': 'cp037', + 'ebcdiccpus': 'cp037', + 'ebcdiccpwt': 'cp037', + 'ecma114': 'iso8859-6', + 'ecma118': 'iso8859-7', + 'elot928': 'iso8859-7', + 'eucjp': 'euc_jp', + 'euckr': 'cp949', + 'extendedunixcodepackedformatforjapanese': 'euc_jp', + 'gb18030': 'gb18030', + 'gb2312': 'gbk', + 'gb231280': 'gbk', + 'gbk': 'gbk', + 'greek': 'iso8859-7', + 'greek8': 'iso8859-7', + 'hebrew': 'iso8859-8', + 'hproman8': 'hp-roman8', + 'hzgb2312': 'hz', + 'ibm037': 'cp037', + 'ibm1026': 'cp1026', + 'ibm367': 'ascii', + 'ibm424': 'cp424', + 'ibm437': 'cp437', + 'ibm500': 'cp500', + 'ibm775': 'cp775', + 'ibm819': 'windows-1252', + 'ibm850': 'cp850', + 'ibm852': 'cp852', + 'ibm855': 'cp855', + 'ibm857': 'cp857', + 'ibm860': 'cp860', + 'ibm861': 'cp861', + 'ibm862': 'cp862', + 'ibm863': 'cp863', + 'ibm864': 'cp864', + 'ibm865': 'cp865', + 'ibm866': 'cp866', + 'ibm869': 'cp869', + 'iso2022jp': 'iso2022_jp', + 'iso2022jp2': 'iso2022_jp_2', + 'iso2022kr': 'iso2022_kr', + 'iso646irv1991': 'ascii', + 'iso646us': 'ascii', + 'iso88591': 'windows-1252', + 'iso885910': 'iso8859-10', + 'iso8859101992': 'iso8859-10', + 'iso885911987': 'windows-1252', + 'iso885913': 'iso8859-13', + 'iso885914': 'iso8859-14', + 'iso8859141998': 'iso8859-14', + 'iso885915': 'iso8859-15', + 'iso885916': 'iso8859-16', + 'iso8859162001': 'iso8859-16', + 'iso88592': 'iso8859-2', + 'iso885921987': 'iso8859-2', + 'iso88593': 'iso8859-3', + 'iso885931988': 'iso8859-3', + 'iso88594': 'iso8859-4', + 'iso885941988': 'iso8859-4', + 'iso88595': 'iso8859-5', + 'iso885951988': 'iso8859-5', + 'iso88596': 'iso8859-6', + 'iso885961987': 'iso8859-6', + 'iso88597': 'iso8859-7', + 'iso885971987': 'iso8859-7', + 'iso88598': 'iso8859-8', + 'iso885981988': 'iso8859-8', + 'iso88599': 'windows-1254', + 'iso885991989': 'windows-1254', + 'isoceltic': 'iso8859-14', + 'isoir100': 'windows-1252', + 'isoir101': 'iso8859-2', + 'isoir109': 'iso8859-3', + 'isoir110': 'iso8859-4', + 'isoir126': 'iso8859-7', + 'isoir127': 'iso8859-6', + 'isoir138': 'iso8859-8', + 'isoir144': 'iso8859-5', + 'isoir148': 'windows-1254', + 'isoir149': 'cp949', + 'isoir157': 'iso8859-10', + 'isoir199': 'iso8859-14', + 'isoir226': 'iso8859-16', + 'isoir58': 'gbk', + 'isoir6': 'ascii', + 'koi8r': 'koi8-r', + 'koi8u': 'koi8-u', + 'korean': 'cp949', + 'ksc5601': 'cp949', + 'ksc56011987': 'cp949', + 'ksc56011989': 'cp949', + 'l1': 'windows-1252', + 'l10': 'iso8859-16', + 'l2': 'iso8859-2', + 'l3': 'iso8859-3', + 'l4': 'iso8859-4', + 'l5': 'windows-1254', + 'l6': 'iso8859-10', + 'l8': 'iso8859-14', + 'latin1': 'windows-1252', + 'latin10': 'iso8859-16', + 'latin2': 'iso8859-2', + 'latin3': 'iso8859-3', + 'latin4': 'iso8859-4', + 'latin5': 'windows-1254', + 'latin6': 'iso8859-10', + 'latin8': 'iso8859-14', + 'latin9': 'iso8859-15', + 'ms936': 'gbk', + 'mskanji': 'shift_jis', + 'pt154': 'ptcp154', + 'ptcp154': 'ptcp154', + 'r8': 'hp-roman8', + 'roman8': 'hp-roman8', + 'shiftjis': 'shift_jis', + 'tis620': 'cp874', + 'unicode11utf7': 'utf-7', + 'us': 'ascii', + 'usascii': 'ascii', + 'utf16': 'utf-16', + 'utf16be': 'utf-16-be', + 'utf16le': 'utf-16-le', + 'utf8': 'utf-8', + 'windows1250': 'cp1250', + 'windows1251': 'cp1251', + 'windows1252': 'cp1252', + 'windows1253': 'cp1253', + 'windows1254': 'cp1254', + 'windows1255': 'cp1255', + 'windows1256': 'cp1256', + 'windows1257': 'cp1257', + 'windows1258': 'cp1258', + 'windows936': 'gbk', + 'x-x-big5': 'big5'}; + +final _StartTagType = 3, _EndTagType = 4, _EmptyTagType = 5; + +final tokenTypes = const { + "Doctype":0, + "Characters":1, + "SpaceCharacters":2, + "StartTag":_StartTagType, + "EndTag":_EndTagType, + "EmptyTag":_EmptyTagType, + "Comment":6, + "ParseError":7 +}; + +bool isTagTokenType(int tagType) { + switch (tagType) { + case _StartTagType: + case _EndTagType: + case _EmptyTagType: + return true; + } + return false; +} + +var _prefixes; +Map get prefixes() { + if (_prefixes != null) { + _prefixes = {}; + namespaces.forEach((k, v) { _prefixes[v] = k; }); + _prefixes["http://www.w3.org/1998/Math/MathML"] = "math"; + } + return _prefixes; +} + diff --git a/encoding_parser.dart b/encoding_parser.dart new file mode 100644 index 0000000..a7d4b5d --- /dev/null +++ b/encoding_parser.dart @@ -0,0 +1,387 @@ +#library('encoding_parser'); + +#import('constants.dart'); +#import('inputstream.dart'); +#import('utils.dart'); + +// TODO(jmesserly): I converted StopIteration to NoMoreElementsException. Seems +// strange to throw this from outside of an iterator though. +/** + * String-like object with an associated position and various extra methods + * If the position is ever greater than the string length then an exception is + * raised. + */ +class EncodingBytes implements Iterable { + final String _bytes; + int _position; + + EncodingBytes(String bytes) : _bytes = bytes, _position = -1; + + Iterator iterator() => _bytes.splitChars().iterator(); + int get length() => _bytes.length; + + String next() { + var p = _position = _position + 1; + if (p >= length) { + throw const NoMoreElementsException(); + } else if (p < 0) { + throw new IndexOutOfRangeException(p); + } + return _bytes[p]; + } + + String previous() { + var p = _position; + if (p >= length) { + throw const NoMoreElementsException(); + } else if (p < 0) { + throw new IndexOutOfRangeException(p); + } + _position = p = p - 1; + return _bytes[p]; + } + + set position(int value) { + if (_position >= length) { + throw const NoMoreElementsException(); + } + _position = value; + } + + int get position() { + if (_position >= length) { + throw const NoMoreElementsException(); + } + if (_position >= 0) { + return _position; + } else { + return 0; + } + } + + String get currentByte() => _bytes[position]; + + /** Skip past a list of characters. Defaults to skipping [isWhitespace]. */ + String skip([CharPreciate skipChars]) { + if (skipChars == null) skipChars = isWhitespace; + var p = position; // use property for the error-checking + while (p < length) { + var c = _bytes[p]; + if (!skipChars(c)) { + _position = p; + return c; + } + p += 1; + } + _position = p; + return null; + } + + String skipUntil(CharPreciate untilChars) { + var p = position; + while (p < length) { + var c = _bytes[p]; + if (untilChars(c)) { + _position = p; + return c; + } + p += 1; + } + return null; + } + + /** + * Look for a sequence of bytes at the start of a string. If the bytes + * are found return true and advance the position to the byte after the + * match. Otherwise return false and leave the position alone. + */ + bool matchBytes(String bytes) { + var p = position; + if (_bytes.length < p + bytes.length) { + return false; + } + var data = _bytes.substring(p, p + bytes.length); + if (data == bytes) { + position += bytes.length; + return true; + } + return false; + } + + /** + * Look for the next sequence of bytes matching a given sequence. If + * a match is found advance the position to the last byte of the match + */ + bool jumpTo(String bytes) { + var newPosition = _bytes.indexOf(bytes, position); + if (newPosition >= 0) { + // XXX: This is ugly, but I can't see a nicer way to fix this. + if (_position == -1) { + _position = 0; + } + _position += newPosition + bytes.length - 1; + return true; + } else { + throw const NoMoreElementsException(); + } + } + + String slice(int start, [int end]) { + if (end == null) end = length; + if (end < 0) end += length; + return _bytes.substring(start, end - start); + } +} + +/** Mini parser for detecting character encoding from meta elements. */ +class EncodingParser { + final EncodingBytes data; + String encoding; + + /** [bytes] - the data to work on for encoding detection. */ + EncodingParser(List bytes) + // Note: this is intentionally interpreting bytes as codepoints. + : data = new EncodingBytes(new String.fromCharCodes(bytes).toLowerCase()); + + String getEncoding() { + final methodDispatch = [ + [""); + + bool handleMeta() { + if (!isWhitespace(data.currentByte)) { + // if we have handlePossibleTag(false); + + bool handlePossibleEndTag() { + data.next(); + return handlePossibleTag(true); + } + + bool handlePossibleTag(bool endTag) { + if (!isLetter(data.currentByte)) { + //If the next byte is not an ascii letter either ignore this + //fragment (possible start tag case) or treat it according to + //handleOther + if (endTag) { + data.previous(); + handleOther(); + } + return true; + } + + var c = data.skipUntil(isSpaceOrAngleBracket); + if (c == "<") { + // return to the first step in the overall "two step" algorithm + // reprocessing the < byte + data.previous(); + } else { + //Read all attributes + var attr = getAttribute(); + while (attr != null) { + attr = getAttribute(); + } + } + return true; + } + + bool handleOther() => data.jumpTo(">"); + + /** + * Return a name,value pair for the next attribute in the stream, + * if one is found, or null + */ + List getAttribute() { + // Step 1 (skip chars) + var c = data.skip((x) => x == "/" || isWhitespace(x)); + // Step 2 + if (c == ">" || c == null) { + return null; + } + // Step 3 + var attrName = []; + var attrValue = []; + // Step 4 attribute name + while (true) { + if (c == null) { + return null; + } else if (c == "=" && attrName.length > 0) { + break; + } else if (isWhitespace(c)) { + // Step 6! + c = data.skip(); + c = data.next(); + break; + } else if (c == "/" || c == ">") { + return [joinStr(attrName), ""]; + } else if (isLetter(c)) { + attrName.add(c.toLowerCase()); + } else { + attrName.add(c); + } + // Step 5 + c = data.next(); + } + // Step 7 + if (c != "=") { + data.previous(); + return [joinStr(attrName), ""]; + } + // Step 8 + data.next(); + // Step 9 + c = data.skip(); + // Step 10 + if (c == "'" || c == '"') { + // 10.1 + var quoteChar = c; + while (true) { + // 10.2 + c = data.next(); + if (c == quoteChar) { + // 10.3 + data.next(); + return [joinStr(attrName), joinStr(attrValue)]; + } else if (isLetter(c)) { + // 10.4 + attrValue.add(c.toLowerCase()); + } else { + // 10.5 + attrValue.add(c); + } + } + } else if (c == ">") { + return [joinStr(attrName), ""]; + } else if (c === null) { + return null; + } else if (isLetter(c)) { + attrValue.add(c.toLowerCase()); + } else { + attrValue.add(c); + } + // Step 11 + while (true) { + c = data.next(); + if (isSpaceOrAngleBracket(c)) { + return [joinStr(attrName), joinStr(attrValue)]; + } else if (c === null) { + return null; + } else if (isLetter(c)) { + attrValue.add(c.toLowerCase()); + } else { + attrValue.add(c); + } + } + } +} + + +class ContentAttrParser { + final EncodingBytes data; + + ContentAttrParser(this.data); + + String parse() { + try { + // Check if the attr name is charset + // otherwise return + data.jumpTo("charset"); + data.position += 1; + data.skip(); + if (data.currentByte != "=") { + // If there is no = sign keep looking for attrs + return null; + } + data.position += 1; + data.skip(); + // Look for an encoding between matching quote marks + if (data.currentByte == '"' || data.currentByte == "'") { + var quoteMark = data.currentByte; + data.position += 1; + var oldPosition = data.position; + if (data.jumpTo(quoteMark)) { + return data.slice(oldPosition, data.position); + } else { + return null; + } + } else { + // Unquoted value + var oldPosition = data.position; + try { + data.skipUntil(isWhitespace); + return data.slice(oldPosition, data.position); + } catch (NoMoreElementsException e) { + //Return the whole remaining value + return data.slice(oldPosition); + } + } + } catch (NoMoreElementsException e) { + return null; + } + } +} + + +bool isSpaceOrAngleBracket(String char) { + return char == ">" || char == "<" || isWhitespace(char); +} + +typedef bool CharPreciate(String char); diff --git a/inputstream.dart b/inputstream.dart new file mode 100644 index 0000000..1274dd1 --- /dev/null +++ b/inputstream.dart @@ -0,0 +1,434 @@ +#library('inputstream'); + +#import('dart:io'); +#import('dart:utf'); +#import('codecs.dart', prefix: 'codecs'); +#import('constants.dart'); +#import('utils.dart'); +#import('encoding_parser.dart'); + + +/** + * Provides a unicode stream of characters to the HTMLTokenizer. + * + * This class takes care of character encoding and removing or replacing + * incorrect byte-sequences and also provides column and line tracking. + */ +class HTMLInputStream { + + const int _defaultChunkSize = 10240; + + /** List of where new lines occur. */ + List newLines; + + /** + * Number of bytes to use when looking for a meta element with + * encoding information. + */ + const int numBytesMeta = 512; + + /** Encoding to use if no other information can be found. */ + const String defaultEncoding = "windows-1252"; + + /** The name of the character encoding. */ + String charEncodingName; + + /** True if we are certain about [charEncodingName], false for tenative. */ + bool charEncodingCertain = true; + + List rawBytes; + + Iterator dataStream; + + /** Cache for charsUntil() */ + Map charsUntilRegEx; + + List errors; + + String chunk; + + int chunkOffset; + + /** number of (complete) lines in previous chunks */ + int prevNumLines; + + /** number of columns in the last line of the previous chunk */ + int prevNumCols; + + /** Deals with CR LF and surrogates split over chunk boundaries */ + String _bufferedCharacter; + + /** + * Initialises the HTMLInputStream. + * + * HTMLInputStream(source, [encoding]) -> Normalized stream from source + * for use by html5lib. + * + * [source] can be either a [RandomAccessFile], a [String], or a [List] + * containing the raw bytes. + * + * The optional encoding parameter must be a string that indicates + * the encoding. If specified, that encoding will be used, + * regardless of any BOM or later declaration (such as in a meta + * element) + * + * [parseMeta] - Look for a element containing encoding information + */ + HTMLInputStream(source, [String encoding, bool parseMeta = true]) + : newLines = [0], + charEncodingName = codecName(encoding), + charsUntilRegEx = new Map() { + + if (source is String) { + // TODO(jmesserly): if the data is already a string, we should just use + // the source.charCodes() instead of wasting time encoding/decoding. + rawBytes = encodeUtf8(source); + charEncodingName = 'utf-8'; + charEncodingCertain = true; + } else if (source is RandomAccessFile) { + // TODO(jmesserly): it's unfortunate we need to read all bytes in advance, + // but it's necessary because of how the UTF decoders work. + rawBytes = readAllBytesFromFile(source); + } else if (source is List) { + rawBytes = source; + } else { + // TODO(jmesserly): we should accept some kind of stream API too. + // Unfortunately dart:io InputStream is async only, which won't work. + throw new IllegalArgumentException( + 'source must be a String, RandomAccessFile, or List'); + } + + // Detect encoding iff no explicit "transport level" encoding is supplied + if (charEncodingName == null) { + detectEncoding(parseMeta); + } + + reset(); + } + + void reset() { + dataStream = null; + chunk = ""; + chunkOffset = 0; + errors = []; + prevNumLines = 0; + prevNumCols = 0; + _bufferedCharacter = null; + } + + + void detectEncoding([bool parseMeta = true]) { + // First look for a BOM + // This will also read past the BOM if present + charEncodingName = detectBOM(); + charEncodingCertain = true; + + // If there is no BOM need to look for meta elements with encoding + // information + if (charEncodingName === null && parseMeta) { + charEncodingName = detectEncodingMeta(); + charEncodingCertain = false; + } + // If all else fails use the default encoding + if (charEncodingName === null) { + charEncodingCertain = false; + charEncodingName = defaultEncoding; + } + + // Substitute for equivalent encodings: + if (charEncodingName.toLowerCase() == "iso-8859-1") { + charEncodingName = "windows-1252"; + } + } + + void changeEncoding(String newEncoding) { + newEncoding = codecName(newEncoding); + if (const ["utf-16", "utf-16-be", "utf-16-le"].indexOf(newEncoding) >= 0) { + newEncoding = "utf-8"; + } + if (newEncoding === null) { + return; + } else if (newEncoding == charEncodingName) { + charEncodingCertain = true; + } else { + reset(); + charEncodingName = newEncoding; + charEncodingCertain = true; + throw new Exception( + "Encoding changed from $charEncodingName to $newEncoding"); + } + } + + /** + * Attempts to detect at BOM at the start of the stream. If + * an encoding can be determined from the BOM return the name of the + * encoding otherwise return null. + */ + String detectBOM() { + // Try detecting the BOM using bytes from the string + if (codecs.hasUtf8Bom(rawBytes)) { + return 'utf-8'; + } + // Note: we don't need to remember whether it was big or little endian + // because the decoder will do that later. It will also eat the BOM for us. + if (hasUtf16Bom(rawBytes)) { + return 'utf-16'; + } + if (hasUtf32Bom(rawBytes)) { + return 'utf-32'; + } + return null; + } + + /** Report the encoding declared by the meta element. */ + String detectEncodingMeta() { + var parser = new EncodingParser(slice(rawBytes, 0, numBytesMeta)); + var encoding = parser.getEncoding(); + + if (const ["utf-16", "utf-16-be", "utf-16-le"].indexOf(encoding) >= 0) { + encoding = "utf-8"; + } + + return encoding; + } + + List _position(offset) { + var nLines = 0; + for (int i = 0; i < offset; i++) { + if (chunk.charCodeAt(i) == NEWLINE) nLines++; + } + var positionLine = prevNumLines + nLines; + var lastLinePos = chunk.lastIndexOf('\n', offset); + var positionColumn; + if (lastLinePos == -1) { + positionColumn = prevNumCols + offset; + } else { + positionColumn = offset - (lastLinePos + 1); + } + return [positionLine, positionColumn]; + } + + /** Returns (line, col) of the current position in the stream. */ + List position() { + var pos = _position(chunkOffset); + pos[0] += 1; + return pos; + } + + /** + * Read one character from the stream or queue if available. Return + * EOF when EOF is reached. + */ + String char() { + // Read a new chunk from the input stream if necessary + if (chunkOffset >= chunk.length) { + if (!readChunk()) { + return EOF; + } + } + + return chunk[chunkOffset++]; + } + + + // TODO(jmesserly): fix the performance of this method. Lots of things would + // be better dealt with in the tokenizer. At the very least we should try to + // avoid so many allocations... + bool readChunk([int readSize]) { + if (readSize === null) { + readSize = _defaultChunkSize; + } + + var pos = _position(chunk.length); + prevNumLines = pos[0]; + prevNumCols = pos[1]; + + chunk = ""; + chunkOffset = 0; + + if (dataStream == null) { + // perform the initial decode + dataStream = codecs.decodeBytes(charEncodingName, rawBytes).iterator(); + } + var charCodes = []; + for (int i = 0; i < readSize && dataStream.hasNext(); i++) { + charCodes.add(dataStream.next()); + } + var data = codepointsToString(charCodes); + + // Deal with CR LF and surrogates broken across chunks + if (_bufferedCharacter != null) { + data = '${_bufferedCharacter}${data}'; + _bufferedCharacter = null; + } else if (data.length == 0) { + // We have no more data, bye-bye stream + return false; + } + + if (data.length > 1) { + var lastv = data.charCodeAt(data.length - 1); + if (lastv == 0x0D || 0xD800 <= lastv && lastv <= 0xDBFF) { + _bufferedCharacter = data[data.length - 1]; + data = data.substring(0, data.length - 1); + } + } + + // Replace invalid characters + // Note U+0000 is dealt with in the tokenizer + chunk = replaceCharacters(data); + + return true; + } + + /** + * Returns a string of characters from the stream up to but not + * including any character in 'characters' or EOF. + */ + String charsUntil(String characters, [bool opposite = false]) { + // Use a cache of regexps to find the required characters + var regexpKey = new Pair(characters, opposite ? 'opposite' : ''); + var chars = charsUntilRegEx[regexpKey]; + + if (chars == null) { + escapeChar(c) { + assert(c < 128); + var hex = c.toRadixString(16); + hex = (hex.length == 1) ? "0$hex" : hex; + return "\\u00$hex"; + } + var regex = joinStr(characters.charCodes().map(escapeChar)); + if (!opposite) { + regex = "^${regex}"; + } + chars = charsUntilRegEx[regexpKey] = new RegExp("^[${regex}]+"); + } + + var rv = []; + while (true) { + // Find the longest matching prefix + // TODO(jmesserly): RegExp does not seem to offer a start offset? + var searchChunk = chunk.substring(chunkOffset); + var m = chars.firstMatch(searchChunk); + if (m === null) { + // If nothing matched, and it wasn't because we ran out of chunk, + // then stop + if (chunkOffset != chunk.length) { + break; + } + } else { + assert(m.start() == 0); + var end = m.end(); + // If not the whole chunk matched, return everything + // up to the part that didn't match + if (end != chunk.length - chunkOffset) { + rv.add(searchChunk.substring(0, end)); + chunkOffset += end; + break; + } + } + // If the whole remainder of the chunk matched, + // use it all and read the next chunk + rv.add(searchChunk); + if (!readChunk()) { + // Reached EOF + break; + } + } + return joinStr(rv); + } + + void unget(String ch) { + // Only one character is allowed to be ungotten at once - it must + // be consumed again before any further call to unget + if (ch != null) { + if (chunkOffset == 0) { + // unget is called quite rarely, so it's a good idea to do + // more work here if it saves a bit of work in the frequently + // called char and charsUntil. + // So, just prepend the ungotten character onto the current + // chunk: + chunk = '${ch}${chunk}'; + } else { + chunkOffset -= 1; + assert(chunk[chunkOffset] == ch); + } + } + } + + String replaceCharacters(String str) { + // TODO(jmesserly): it'd be nice not to create the array until we know we + // are replacing something. Also it'd be nice to set the initial capacity. + var result = []; + for (int i = 0; i < str.length; i++) { + var c = str.charCodeAt(i); + if (invalidUnicode(c)) errors.add("invalid-codepoint"); + + if (0xD800 <= c && c <= 0xDFFF) { + c = 0xFFFD; + } else if (c == RETURN) { + int j = i + 1; + if (j < str.length && str.charCodeAt(j) == NEWLINE) { + i = j; // \r\n becomes \n + } + c = NEWLINE; + } + result.add(c); + } + return codepointsToString(result); + } +} + + +// TODO(jmesserly): the Python code used a regex to check for this. But +// Dart doesn't let you create a regexp with invalid characters. +bool invalidUnicode(int c) { + if (0x0001 <= c && c <= 0x0008) return true; + if (0x000E <= c && c <= 0x001F) return true; + if (0x007F <= c && c <= 0x009F) return true; + if (0xD800 <= c && c <= 0xDFFF) return true; + if (0xFDD0 <= c && c <= 0xFDEF) return true; + switch (c) { + case 0x000B: case 0xFFFE: case 0xFFFF: case 0x01FFFE: case 0x01FFFF: + case 0x02FFFE: case 0x02FFFF: case 0x03FFFE: case 0x03FFFF: + case 0x04FFFE: case 0x04FFFF: case 0x05FFFE: case 0x05FFFF: + case 0x06FFFE: case 0x06FFFF: case 0x07FFFE: case 0x07FFFF: + case 0x08FFFE: case 0x08FFFF: case 0x09FFFE: case 0x09FFFF: + case 0x0AFFFE: case 0x0AFFFF: case 0x0BFFFE: case 0x0BFFFF: + case 0x0CFFFE: case 0x0CFFFF: case 0x0DFFFE: case 0x0DFFFF: + case 0x0EFFFE: case 0x0EFFFF: case 0x0FFFFE: case 0x0FFFFF: + case 0x10FFFE: case 0x10FFFF: + return true; + } + return false; +} + +List readAllBytesFromFile(RandomAccessFile file) { + int length = file.lengthSync(); + var bytes = new List(length); + + int bytesRead = 0; + while (bytesRead < length) { + int read = file.readListSync(bytes, bytesRead, length - bytesRead); + if (read <= 0) { + // This could happen if, for example, the file was resized while + // we're reading. Just shrink the bytes array and move on. + bytes = bytes.getRange(0, bytesRead); + break; + } + bytesRead += read; + } + return bytes; +} + +/** + * Return the python codec name corresponding to an encoding or null if the + * string doesn't correspond to a valid encoding. + */ +String codecName(String encoding) { + final asciiPunctuation = const RegExp( + "[\u0009-\u000D\u0020-\u002F\u003A-\u0040\u005B-\u0060\u007B-\u007E]"); + + if (encoding == null) return null; + var canonicalName = encoding.replaceAll(asciiPunctuation, '').toLowerCase(); + return encodings[canonicalName]; +} diff --git a/pubspec.yaml b/pubspec.yaml new file mode 100644 index 0000000..a638945 --- /dev/null +++ b/pubspec.yaml @@ -0,0 +1,8 @@ +name: html5lib +description: library for working with HTML documents +version: 0.0.1 +dependencies: + unittest: + sdk: unittest + args: + sdk: args diff --git a/tests/data/tokenizer/contentModelFlags.test b/tests/data/tokenizer/contentModelFlags.test new file mode 100644 index 0000000..a8b1695 --- /dev/null +++ b/tests/data/tokenizer/contentModelFlags.test @@ -0,0 +1,75 @@ +{"tests": [ + +{"description":"PLAINTEXT content model flag", +"initialStates":["PLAINTEXT state"], +"lastStartTag":"plaintext", +"input":"&body;", +"output":[["Character", "&body;"]]}, + +{"description":"End tag closing RCDATA or RAWTEXT", +"initialStates":["RCDATA state", "RAWTEXT state"], +"lastStartTag":"xmp", +"input":"foo", +"output":[["Character", "foo"], ["EndTag", "xmp"]]}, + +{"description":"End tag closing RCDATA or RAWTEXT (case-insensitivity)", +"initialStates":["RCDATA state", "RAWTEXT state"], +"lastStartTag":"xmp", +"input":"foo", +"output":[["Character", "foo"], ["EndTag", "xmp"]]}, + +{"description":"End tag closing RCDATA or RAWTEXT (ending with space)", +"initialStates":["RCDATA state", "RAWTEXT state"], +"lastStartTag":"xmp", +"input":"foobar", +"output":[["Character", "bar"], ["EndTag", "xmp"]]}, + +{"description":"End tag with incorrect name in RCDATA or RAWTEXT (starting like correct name)", +"initialStates":["RCDATA state", "RAWTEXT state"], +"lastStartTag":"xmp", +"input":"bar", +"output":[["Character", "bar"]]}, + +{"description":"End tag closing RCDATA or RAWTEXT, switching back to PCDATA", +"initialStates":["RCDATA state", "RAWTEXT state"], +"lastStartTag":"xmp", +"input":"foo", +"output":[["Character", "foo"], ["EndTag", "xmp"], ["EndTag", "baz"]]}, + +{"description":"RAWTEXT w/ something looking like an entity", +"initialStates":["RAWTEXT state"], +"lastStartTag":"xmp", +"input":"&foo;", +"output":[["Character", "&foo;"]]}, + +{"description":"RCDATA w/ an entity", +"initialStates":["RCDATA state"], +"lastStartTag":"textarea", +"input":"<", +"output":[["Character", "<"]]} + +]} diff --git a/tests/data/tokenizer/domjs.test b/tests/data/tokenizer/domjs.test new file mode 100644 index 0000000..74771e2 --- /dev/null +++ b/tests/data/tokenizer/domjs.test @@ -0,0 +1,90 @@ +{ + "tests": [ + { + "description":"CR in bogus comment state", + "input":"", + "output":[["EndTag","xmp"]] + }, + { + "description":"bad endtag in RCDATA and RAWTEXT", + "initialStates":["RCDATA state", "RAWTEXT state"], + "lastStartTag":"xmp", + "input":"", + "output":[["Character",""]] + }, + { + "description":"bad endtag in RCDATA and RAWTEXT", + "initialStates":["RCDATA state", "RAWTEXT state"], + "lastStartTag":"xmp", + "input":"", + "output":[["Character",""]] + }, + { + "description":"bad endtag in RCDATA and RAWTEXT", + "initialStates":["RCDATA state", "RAWTEXT state"], + "lastStartTag":"xmp", + "input":"", + "output":[["StartTag", "p", {"id":"\u2242\u0338"}]] + }, + { + "description":"--!NUL in comment ", + "doubleEscaped":true, + "input":"", + "output":["ParseError", ["Comment", "--!\\uFFFD"]] + }, + { + "description":"space EOF after doctype ", + "input":"", +"output": ["ParseError", ["StartTag", "h", {"a": "¬i;"}]]}, + +{"description": "Entity name followed by the equals sign in an attribute value.", +"input":"", +"output": ["ParseError", ["StartTag", "h", {"a": "&lang="}]]}, + +{"description": "CR as numeric entity", +"input":" ", +"output": ["ParseError", ["Character", "\r"]]}, + +{"description": "CR as hexadecimal numeric entity", +"input":" ", +"output": ["ParseError", ["Character", "\r"]]}, + +{"description": "Windows-1252 EURO SIGN numeric entity.", +"input":"€", +"output": ["ParseError", ["Character", "\u20AC"]]}, + +{"description": "Windows-1252 REPLACEMENT CHAR numeric entity.", +"input":"", +"output": ["ParseError", ["Character", "\u0081"]]}, + +{"description": "Windows-1252 SINGLE LOW-9 QUOTATION MARK numeric entity.", +"input":"‚", +"output": ["ParseError", ["Character", "\u201A"]]}, + +{"description": "Windows-1252 LATIN SMALL LETTER F WITH HOOK numeric entity.", +"input":"ƒ", +"output": ["ParseError", ["Character", "\u0192"]]}, + +{"description": "Windows-1252 DOUBLE LOW-9 QUOTATION MARK numeric entity.", +"input":"„", +"output": ["ParseError", ["Character", "\u201E"]]}, + +{"description": "Windows-1252 HORIZONTAL ELLIPSIS numeric entity.", +"input":"…", +"output": ["ParseError", ["Character", "\u2026"]]}, + +{"description": "Windows-1252 DAGGER numeric entity.", +"input":"†", +"output": ["ParseError", ["Character", "\u2020"]]}, + +{"description": "Windows-1252 DOUBLE DAGGER numeric entity.", +"input":"‡", +"output": ["ParseError", ["Character", "\u2021"]]}, + +{"description": "Windows-1252 MODIFIER LETTER CIRCUMFLEX ACCENT numeric entity.", +"input":"ˆ", +"output": ["ParseError", ["Character", "\u02C6"]]}, + +{"description": "Windows-1252 PER MILLE SIGN numeric entity.", +"input":"‰", +"output": ["ParseError", ["Character", "\u2030"]]}, + +{"description": "Windows-1252 LATIN CAPITAL LETTER S WITH CARON numeric entity.", +"input":"Š", +"output": ["ParseError", ["Character", "\u0160"]]}, + +{"description": "Windows-1252 SINGLE LEFT-POINTING ANGLE QUOTATION MARK numeric entity.", +"input":"‹", +"output": ["ParseError", ["Character", "\u2039"]]}, + +{"description": "Windows-1252 LATIN CAPITAL LIGATURE OE numeric entity.", +"input":"Œ", +"output": ["ParseError", ["Character", "\u0152"]]}, + +{"description": "Windows-1252 REPLACEMENT CHAR numeric entity.", +"input":"", +"output": ["ParseError", ["Character", "\u008D"]]}, + +{"description": "Windows-1252 LATIN CAPITAL LETTER Z WITH CARON numeric entity.", +"input":"Ž", +"output": ["ParseError", ["Character", "\u017D"]]}, + +{"description": "Windows-1252 REPLACEMENT CHAR numeric entity.", +"input":"", +"output": ["ParseError", ["Character", "\u008F"]]}, + +{"description": "Windows-1252 REPLACEMENT CHAR numeric entity.", +"input":"", +"output": ["ParseError", ["Character", "\u0090"]]}, + +{"description": "Windows-1252 LEFT SINGLE QUOTATION MARK numeric entity.", +"input":"‘", +"output": ["ParseError", ["Character", "\u2018"]]}, + +{"description": "Windows-1252 RIGHT SINGLE QUOTATION MARK numeric entity.", +"input":"’", +"output": ["ParseError", ["Character", "\u2019"]]}, + +{"description": "Windows-1252 LEFT DOUBLE QUOTATION MARK numeric entity.", +"input":"“", +"output": ["ParseError", ["Character", "\u201C"]]}, + +{"description": "Windows-1252 RIGHT DOUBLE QUOTATION MARK numeric entity.", +"input":"”", +"output": ["ParseError", ["Character", "\u201D"]]}, + +{"description": "Windows-1252 BULLET numeric entity.", +"input":"•", +"output": ["ParseError", ["Character", "\u2022"]]}, + +{"description": "Windows-1252 EN DASH numeric entity.", +"input":"–", +"output": ["ParseError", ["Character", "\u2013"]]}, + +{"description": "Windows-1252 EM DASH numeric entity.", +"input":"—", +"output": ["ParseError", ["Character", "\u2014"]]}, + +{"description": "Windows-1252 SMALL TILDE numeric entity.", +"input":"˜", +"output": ["ParseError", ["Character", "\u02DC"]]}, + +{"description": "Windows-1252 TRADE MARK SIGN numeric entity.", +"input":"™", +"output": ["ParseError", ["Character", "\u2122"]]}, + +{"description": "Windows-1252 LATIN SMALL LETTER S WITH CARON numeric entity.", +"input":"š", +"output": ["ParseError", ["Character", "\u0161"]]}, + +{"description": "Windows-1252 SINGLE RIGHT-POINTING ANGLE QUOTATION MARK numeric entity.", +"input":"›", +"output": ["ParseError", ["Character", "\u203A"]]}, + +{"description": "Windows-1252 LATIN SMALL LIGATURE OE numeric entity.", +"input":"œ", +"output": ["ParseError", ["Character", "\u0153"]]}, + +{"description": "Windows-1252 REPLACEMENT CHAR numeric entity.", +"input":"", +"output": ["ParseError", ["Character", "\u009D"]]}, + +{"description": "Windows-1252 EURO SIGN hexadecimal numeric entity.", +"input":"€", +"output": ["ParseError", ["Character", "\u20AC"]]}, + +{"description": "Windows-1252 REPLACEMENT CHAR hexadecimal numeric entity.", +"input":"", +"output": ["ParseError", ["Character", "\u0081"]]}, + +{"description": "Windows-1252 SINGLE LOW-9 QUOTATION MARK hexadecimal numeric entity.", +"input":"‚", +"output": ["ParseError", ["Character", "\u201A"]]}, + +{"description": "Windows-1252 LATIN SMALL LETTER F WITH HOOK hexadecimal numeric entity.", +"input":"ƒ", +"output": ["ParseError", ["Character", "\u0192"]]}, + +{"description": "Windows-1252 DOUBLE LOW-9 QUOTATION MARK hexadecimal numeric entity.", +"input":"„", +"output": ["ParseError", ["Character", "\u201E"]]}, + +{"description": "Windows-1252 HORIZONTAL ELLIPSIS hexadecimal numeric entity.", +"input":"…", +"output": ["ParseError", ["Character", "\u2026"]]}, + +{"description": "Windows-1252 DAGGER hexadecimal numeric entity.", +"input":"†", +"output": ["ParseError", ["Character", "\u2020"]]}, + +{"description": "Windows-1252 DOUBLE DAGGER hexadecimal numeric entity.", +"input":"‡", +"output": ["ParseError", ["Character", "\u2021"]]}, + +{"description": "Windows-1252 MODIFIER LETTER CIRCUMFLEX ACCENT hexadecimal numeric entity.", +"input":"ˆ", +"output": ["ParseError", ["Character", "\u02C6"]]}, + +{"description": "Windows-1252 PER MILLE SIGN hexadecimal numeric entity.", +"input":"‰", +"output": ["ParseError", ["Character", "\u2030"]]}, + +{"description": "Windows-1252 LATIN CAPITAL LETTER S WITH CARON hexadecimal numeric entity.", +"input":"Š", +"output": ["ParseError", ["Character", "\u0160"]]}, + +{"description": "Windows-1252 SINGLE LEFT-POINTING ANGLE QUOTATION MARK hexadecimal numeric entity.", +"input":"‹", +"output": ["ParseError", ["Character", "\u2039"]]}, + +{"description": "Windows-1252 LATIN CAPITAL LIGATURE OE hexadecimal numeric entity.", +"input":"Œ", +"output": ["ParseError", ["Character", "\u0152"]]}, + +{"description": "Windows-1252 REPLACEMENT CHAR hexadecimal numeric entity.", +"input":"", +"output": ["ParseError", ["Character", "\u008D"]]}, + +{"description": "Windows-1252 LATIN CAPITAL LETTER Z WITH CARON hexadecimal numeric entity.", +"input":"Ž", +"output": ["ParseError", ["Character", "\u017D"]]}, + +{"description": "Windows-1252 REPLACEMENT CHAR hexadecimal numeric entity.", +"input":"", +"output": ["ParseError", ["Character", "\u008F"]]}, + +{"description": "Windows-1252 REPLACEMENT CHAR hexadecimal numeric entity.", +"input":"", +"output": ["ParseError", ["Character", "\u0090"]]}, + +{"description": "Windows-1252 LEFT SINGLE QUOTATION MARK hexadecimal numeric entity.", +"input":"‘", +"output": ["ParseError", ["Character", "\u2018"]]}, + +{"description": "Windows-1252 RIGHT SINGLE QUOTATION MARK hexadecimal numeric entity.", +"input":"’", +"output": ["ParseError", ["Character", "\u2019"]]}, + +{"description": "Windows-1252 LEFT DOUBLE QUOTATION MARK hexadecimal numeric entity.", +"input":"“", +"output": ["ParseError", ["Character", "\u201C"]]}, + +{"description": "Windows-1252 RIGHT DOUBLE QUOTATION MARK hexadecimal numeric entity.", +"input":"”", +"output": ["ParseError", ["Character", "\u201D"]]}, + +{"description": "Windows-1252 BULLET hexadecimal numeric entity.", +"input":"•", +"output": ["ParseError", ["Character", "\u2022"]]}, + +{"description": "Windows-1252 EN DASH hexadecimal numeric entity.", +"input":"–", +"output": ["ParseError", ["Character", "\u2013"]]}, + +{"description": "Windows-1252 EM DASH hexadecimal numeric entity.", +"input":"—", +"output": ["ParseError", ["Character", "\u2014"]]}, + +{"description": "Windows-1252 SMALL TILDE hexadecimal numeric entity.", +"input":"˜", +"output": ["ParseError", ["Character", "\u02DC"]]}, + +{"description": "Windows-1252 TRADE MARK SIGN hexadecimal numeric entity.", +"input":"™", +"output": ["ParseError", ["Character", "\u2122"]]}, + +{"description": "Windows-1252 LATIN SMALL LETTER S WITH CARON hexadecimal numeric entity.", +"input":"š", +"output": ["ParseError", ["Character", "\u0161"]]}, + +{"description": "Windows-1252 SINGLE RIGHT-POINTING ANGLE QUOTATION MARK hexadecimal numeric entity.", +"input":"›", +"output": ["ParseError", ["Character", "\u203A"]]}, + +{"description": "Windows-1252 LATIN SMALL LIGATURE OE hexadecimal numeric entity.", +"input":"œ", +"output": ["ParseError", ["Character", "\u0153"]]}, + +{"description": "Windows-1252 REPLACEMENT CHAR hexadecimal numeric entity.", +"input":"", +"output": ["ParseError", ["Character", "\u009D"]]}, + +{"description": "Windows-1252 LATIN SMALL LETTER Z WITH CARON hexadecimal numeric entity.", +"input":"ž", +"output": ["ParseError", ["Character", "\u017E"]]}, + +{"description": "Windows-1252 LATIN CAPITAL LETTER Y WITH DIAERESIS hexadecimal numeric entity.", +"input":"Ÿ", +"output": ["ParseError", ["Character", "\u0178"]]}, + +{"description": "Decimal numeric entity followed by hex character a.", +"input":"aa", +"output": ["ParseError", ["Character", "aa"]]}, + +{"description": "Decimal numeric entity followed by hex character A.", +"input":"aA", +"output": ["ParseError", ["Character", "aA"]]}, + +{"description": "Decimal numeric entity followed by hex character f.", +"input":"af", +"output": ["ParseError", ["Character", "af"]]}, + +{"description": "Decimal numeric entity followed by hex character A.", +"input":"aF", +"output": ["ParseError", ["Character", "aF"]]} + +]} diff --git a/tests/data/tokenizer/escapeFlag.test b/tests/data/tokenizer/escapeFlag.test new file mode 100644 index 0000000..18cb430 --- /dev/null +++ b/tests/data/tokenizer/escapeFlag.test @@ -0,0 +1,33 @@ +{"tests": [ + +{"description":"Commented close tag in RCDATA or RAWTEXT", +"initialStates":["RCDATA state", "RAWTEXT state"], +"lastStartTag":"xmp", +"input":"foo", +"output":[["Character", "foo"], ["EndTag", "xmp"]]}, + +{"description":"Bogus comment in RCDATA or RAWTEXT", +"initialStates":["RCDATA state", "RAWTEXT state"], +"lastStartTag":"xmp", +"input":"foobaz", +"output":[["Character", "foobaz"], ["EndTag", "xmp"]]}, + +{"description":"End tag surrounded by bogus comment in RCDATA or RAWTEXT", +"initialStates":["RCDATA state", "RAWTEXT state"], +"lastStartTag":"xmp", +"input":"foobaz", +"output":[["Character", "foo"], ["EndTag", "xmp"], "ParseError", ["Comment", ""], ["Character", "baz"], ["EndTag", "xmp"]]}, + +{"description":"Commented entities in RCDATA", +"initialStates":["RCDATA state"], +"lastStartTag":"xmp", +"input":" & & ", +"output":[["Character", " & & "], ["EndTag", "xmp"]]}, + +{"description":"Incorrect comment ending sequences in RCDATA or RAWTEXT", +"initialStates":["RCDATA state", "RAWTEXT state"], +"lastStartTag":"xmp", +"input":"foox--<>", +"output":[["Character", "foox--<>"], ["EndTag", "xmp"]]} + +]} diff --git a/tests/data/tokenizer/namedEntities.test b/tests/data/tokenizer/namedEntities.test new file mode 100644 index 0000000..4a51c9c --- /dev/null +++ b/tests/data/tokenizer/namedEntities.test @@ -0,0 +1,44189 @@ +{ + "tests": [ + { + "input": "Æ", + "description": "Named entity: AElig without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "\u00c6" + ] + ] + }, + { + "input": "Æ", + "description": "Named entity: AElig; with a semi-colon", + "output": [ + [ + "Character", + "\u00c6" + ] + ] + }, + { + "input": "&", + "description": "Named entity: AMP without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&" + ] + ] + }, + { + "input": "&", + "description": "Named entity: AMP; with a semi-colon", + "output": [ + [ + "Character", + "&" + ] + ] + }, + { + "input": "Á", + "description": "Named entity: Aacute without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "\u00c1" + ] + ] + }, + { + "input": "Á", + "description": "Named entity: Aacute; with a semi-colon", + "output": [ + [ + "Character", + "\u00c1" + ] + ] + }, + { + "input": "&Abreve", + "description": "Bad named entity: Abreve without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&Abreve" + ] + ] + }, + { + "input": "Ă", + "description": "Named entity: Abreve; with a semi-colon", + "output": [ + [ + "Character", + "\u0102" + ] + ] + }, + { + "input": "Â", + "description": "Named entity: Acirc without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "\u00c2" + ] + ] + }, + { + "input": "Â", + "description": "Named entity: Acirc; with a semi-colon", + "output": [ + [ + "Character", + "\u00c2" + ] + ] + }, + { + "input": "&Acy", + "description": "Bad named entity: Acy without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&Acy" + ] + ] + }, + { + "input": "А", + "description": "Named entity: Acy; with a semi-colon", + "output": [ + [ + "Character", + "\u0410" + ] + ] + }, + { + "input": "&Afr", + "description": "Bad named entity: Afr without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&Afr" + ] + ] + }, + { + "input": "𝔄", + "description": "Named entity: Afr; with a semi-colon", + "output": [ + [ + "Character", + "\ud835\udd04" + ] + ] + }, + { + "input": "À", + "description": "Named entity: Agrave without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "\u00c0" + ] + ] + }, + { + "input": "À", + "description": "Named entity: Agrave; with a semi-colon", + "output": [ + [ + "Character", + "\u00c0" + ] + ] + }, + { + "input": "&Alpha", + "description": "Bad named entity: Alpha without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&Alpha" + ] + ] + }, + { + "input": "Α", + "description": "Named entity: Alpha; with a semi-colon", + "output": [ + [ + "Character", + "\u0391" + ] + ] + }, + { + "input": "&Amacr", + "description": "Bad named entity: Amacr without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&Amacr" + ] + ] + }, + { + "input": "Ā", + "description": "Named entity: Amacr; with a semi-colon", + "output": [ + [ + "Character", + "\u0100" + ] + ] + }, + { + "input": "&And", + "description": "Bad named entity: And without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&And" + ] + ] + }, + { + "input": "⩓", + "description": "Named entity: And; with a semi-colon", + "output": [ + [ + "Character", + "\u2a53" + ] + ] + }, + { + "input": "&Aogon", + "description": "Bad named entity: Aogon without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&Aogon" + ] + ] + }, + { + "input": "Ą", + "description": "Named entity: Aogon; with a semi-colon", + "output": [ + [ + "Character", + "\u0104" + ] + ] + }, + { + "input": "&Aopf", + "description": "Bad named entity: Aopf without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&Aopf" + ] + ] + }, + { + "input": "𝔸", + "description": "Named entity: Aopf; with a semi-colon", + "output": [ + [ + "Character", + "\ud835\udd38" + ] + ] + }, + { + "input": "&ApplyFunction", + "description": "Bad named entity: ApplyFunction without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&ApplyFunction" + ] + ] + }, + { + "input": "⁡", + "description": "Named entity: ApplyFunction; with a semi-colon", + "output": [ + [ + "Character", + "\u2061" + ] + ] + }, + { + "input": "Å", + "description": "Named entity: Aring without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "\u00c5" + ] + ] + }, + { + "input": "Å", + "description": "Named entity: Aring; with a semi-colon", + "output": [ + [ + "Character", + "\u00c5" + ] + ] + }, + { + "input": "&Ascr", + "description": "Bad named entity: Ascr without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&Ascr" + ] + ] + }, + { + "input": "𝒜", + "description": "Named entity: Ascr; with a semi-colon", + "output": [ + [ + "Character", + "\ud835\udc9c" + ] + ] + }, + { + "input": "&Assign", + "description": "Bad named entity: Assign without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&Assign" + ] + ] + }, + { + "input": "≔", + "description": "Named entity: Assign; with a semi-colon", + "output": [ + [ + "Character", + "\u2254" + ] + ] + }, + { + "input": "Ã", + "description": "Named entity: Atilde without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "\u00c3" + ] + ] + }, + { + "input": "Ã", + "description": "Named entity: Atilde; with a semi-colon", + "output": [ + [ + "Character", + "\u00c3" + ] + ] + }, + { + "input": "Ä", + "description": "Named entity: Auml without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "\u00c4" + ] + ] + }, + { + "input": "Ä", + "description": "Named entity: Auml; with a semi-colon", + "output": [ + [ + "Character", + "\u00c4" + ] + ] + }, + { + "input": "&Backslash", + "description": "Bad named entity: Backslash without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&Backslash" + ] + ] + }, + { + "input": "∖", + "description": "Named entity: Backslash; with a semi-colon", + "output": [ + [ + "Character", + "\u2216" + ] + ] + }, + { + "input": "&Barv", + "description": "Bad named entity: Barv without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&Barv" + ] + ] + }, + { + "input": "⫧", + "description": "Named entity: Barv; with a semi-colon", + "output": [ + [ + "Character", + "\u2ae7" + ] + ] + }, + { + "input": "&Barwed", + "description": "Bad named entity: Barwed without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&Barwed" + ] + ] + }, + { + "input": "⌆", + "description": "Named entity: Barwed; with a semi-colon", + "output": [ + [ + "Character", + "\u2306" + ] + ] + }, + { + "input": "&Bcy", + "description": "Bad named entity: Bcy without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&Bcy" + ] + ] + }, + { + "input": "Б", + "description": "Named entity: Bcy; with a semi-colon", + "output": [ + [ + "Character", + "\u0411" + ] + ] + }, + { + "input": "&Because", + "description": "Bad named entity: Because without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&Because" + ] + ] + }, + { + "input": "∵", + "description": "Named entity: Because; with a semi-colon", + "output": [ + [ + "Character", + "\u2235" + ] + ] + }, + { + "input": "&Bernoullis", + "description": "Bad named entity: Bernoullis without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&Bernoullis" + ] + ] + }, + { + "input": "ℬ", + "description": "Named entity: Bernoullis; with a semi-colon", + "output": [ + [ + "Character", + "\u212c" + ] + ] + }, + { + "input": "&Beta", + "description": "Bad named entity: Beta without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&Beta" + ] + ] + }, + { + "input": "Β", + "description": "Named entity: Beta; with a semi-colon", + "output": [ + [ + "Character", + "\u0392" + ] + ] + }, + { + "input": "&Bfr", + "description": "Bad named entity: Bfr without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&Bfr" + ] + ] + }, + { + "input": "𝔅", + "description": "Named entity: Bfr; with a semi-colon", + "output": [ + [ + "Character", + "\ud835\udd05" + ] + ] + }, + { + "input": "&Bopf", + "description": "Bad named entity: Bopf without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&Bopf" + ] + ] + }, + { + "input": "𝔹", + "description": "Named entity: Bopf; with a semi-colon", + "output": [ + [ + "Character", + "\ud835\udd39" + ] + ] + }, + { + "input": "&Breve", + "description": "Bad named entity: Breve without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&Breve" + ] + ] + }, + { + "input": "˘", + "description": "Named entity: Breve; with a semi-colon", + "output": [ + [ + "Character", + "\u02d8" + ] + ] + }, + { + "input": "&Bscr", + "description": "Bad named entity: Bscr without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&Bscr" + ] + ] + }, + { + "input": "ℬ", + "description": "Named entity: Bscr; with a semi-colon", + "output": [ + [ + "Character", + "\u212c" + ] + ] + }, + { + "input": "&Bumpeq", + "description": "Bad named entity: Bumpeq without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&Bumpeq" + ] + ] + }, + { + "input": "≎", + "description": "Named entity: Bumpeq; with a semi-colon", + "output": [ + [ + "Character", + "\u224e" + ] + ] + }, + { + "input": "&CHcy", + "description": "Bad named entity: CHcy without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&CHcy" + ] + ] + }, + { + "input": "Ч", + "description": "Named entity: CHcy; with a semi-colon", + "output": [ + [ + "Character", + "\u0427" + ] + ] + }, + { + "input": "©", + "description": "Named entity: COPY without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "\u00a9" + ] + ] + }, + { + "input": "©", + "description": "Named entity: COPY; with a semi-colon", + "output": [ + [ + "Character", + "\u00a9" + ] + ] + }, + { + "input": "&Cacute", + "description": "Bad named entity: Cacute without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&Cacute" + ] + ] + }, + { + "input": "Ć", + "description": "Named entity: Cacute; with a semi-colon", + "output": [ + [ + "Character", + "\u0106" + ] + ] + }, + { + "input": "&Cap", + "description": "Bad named entity: Cap without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&Cap" + ] + ] + }, + { + "input": "⋒", + "description": "Named entity: Cap; with a semi-colon", + "output": [ + [ + "Character", + "\u22d2" + ] + ] + }, + { + "input": "&CapitalDifferentialD", + "description": "Bad named entity: CapitalDifferentialD without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&CapitalDifferentialD" + ] + ] + }, + { + "input": "ⅅ", + "description": "Named entity: CapitalDifferentialD; with a semi-colon", + "output": [ + [ + "Character", + "\u2145" + ] + ] + }, + { + "input": "&Cayleys", + "description": "Bad named entity: Cayleys without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&Cayleys" + ] + ] + }, + { + "input": "ℭ", + "description": "Named entity: Cayleys; with a semi-colon", + "output": [ + [ + "Character", + "\u212d" + ] + ] + }, + { + "input": "&Ccaron", + "description": "Bad named entity: Ccaron without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&Ccaron" + ] + ] + }, + { + "input": "Č", + "description": "Named entity: Ccaron; with a semi-colon", + "output": [ + [ + "Character", + "\u010c" + ] + ] + }, + { + "input": "Ç", + "description": "Named entity: Ccedil without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "\u00c7" + ] + ] + }, + { + "input": "Ç", + "description": "Named entity: Ccedil; with a semi-colon", + "output": [ + [ + "Character", + "\u00c7" + ] + ] + }, + { + "input": "&Ccirc", + "description": "Bad named entity: Ccirc without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&Ccirc" + ] + ] + }, + { + "input": "Ĉ", + "description": "Named entity: Ccirc; with a semi-colon", + "output": [ + [ + "Character", + "\u0108" + ] + ] + }, + { + "input": "&Cconint", + "description": "Bad named entity: Cconint without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&Cconint" + ] + ] + }, + { + "input": "∰", + "description": "Named entity: Cconint; with a semi-colon", + "output": [ + [ + "Character", + "\u2230" + ] + ] + }, + { + "input": "&Cdot", + "description": "Bad named entity: Cdot without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&Cdot" + ] + ] + }, + { + "input": "Ċ", + "description": "Named entity: Cdot; with a semi-colon", + "output": [ + [ + "Character", + "\u010a" + ] + ] + }, + { + "input": "&Cedilla", + "description": "Bad named entity: Cedilla without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&Cedilla" + ] + ] + }, + { + "input": "¸", + "description": "Named entity: Cedilla; with a semi-colon", + "output": [ + [ + "Character", + "\u00b8" + ] + ] + }, + { + "input": "&CenterDot", + "description": "Bad named entity: CenterDot without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&CenterDot" + ] + ] + }, + { + "input": "·", + "description": "Named entity: CenterDot; with a semi-colon", + "output": [ + [ + "Character", + "\u00b7" + ] + ] + }, + { + "input": "&Cfr", + "description": "Bad named entity: Cfr without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&Cfr" + ] + ] + }, + { + "input": "ℭ", + "description": "Named entity: Cfr; with a semi-colon", + "output": [ + [ + "Character", + "\u212d" + ] + ] + }, + { + "input": "&Chi", + "description": "Bad named entity: Chi without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&Chi" + ] + ] + }, + { + "input": "Χ", + "description": "Named entity: Chi; with a semi-colon", + "output": [ + [ + "Character", + "\u03a7" + ] + ] + }, + { + "input": "&CircleDot", + "description": "Bad named entity: CircleDot without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&CircleDot" + ] + ] + }, + { + "input": "⊙", + "description": "Named entity: CircleDot; with a semi-colon", + "output": [ + [ + "Character", + "\u2299" + ] + ] + }, + { + "input": "&CircleMinus", + "description": "Bad named entity: CircleMinus without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&CircleMinus" + ] + ] + }, + { + "input": "⊖", + "description": "Named entity: CircleMinus; with a semi-colon", + "output": [ + [ + "Character", + "\u2296" + ] + ] + }, + { + "input": "&CirclePlus", + "description": "Bad named entity: CirclePlus without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&CirclePlus" + ] + ] + }, + { + "input": "⊕", + "description": "Named entity: CirclePlus; with a semi-colon", + "output": [ + [ + "Character", + "\u2295" + ] + ] + }, + { + "input": "&CircleTimes", + "description": "Bad named entity: CircleTimes without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&CircleTimes" + ] + ] + }, + { + "input": "⊗", + "description": "Named entity: CircleTimes; with a semi-colon", + "output": [ + [ + "Character", + "\u2297" + ] + ] + }, + { + "input": "&ClockwiseContourIntegral", + "description": "Bad named entity: ClockwiseContourIntegral without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&ClockwiseContourIntegral" + ] + ] + }, + { + "input": "∲", + "description": "Named entity: ClockwiseContourIntegral; with a semi-colon", + "output": [ + [ + "Character", + "\u2232" + ] + ] + }, + { + "input": "&CloseCurlyDoubleQuote", + "description": "Bad named entity: CloseCurlyDoubleQuote without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&CloseCurlyDoubleQuote" + ] + ] + }, + { + "input": "”", + "description": "Named entity: CloseCurlyDoubleQuote; with a semi-colon", + "output": [ + [ + "Character", + "\u201d" + ] + ] + }, + { + "input": "&CloseCurlyQuote", + "description": "Bad named entity: CloseCurlyQuote without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&CloseCurlyQuote" + ] + ] + }, + { + "input": "’", + "description": "Named entity: CloseCurlyQuote; with a semi-colon", + "output": [ + [ + "Character", + "\u2019" + ] + ] + }, + { + "input": "&Colon", + "description": "Bad named entity: Colon without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&Colon" + ] + ] + }, + { + "input": "∷", + "description": "Named entity: Colon; with a semi-colon", + "output": [ + [ + "Character", + "\u2237" + ] + ] + }, + { + "input": "&Colone", + "description": "Bad named entity: Colone without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&Colone" + ] + ] + }, + { + "input": "⩴", + "description": "Named entity: Colone; with a semi-colon", + "output": [ + [ + "Character", + "\u2a74" + ] + ] + }, + { + "input": "&Congruent", + "description": "Bad named entity: Congruent without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&Congruent" + ] + ] + }, + { + "input": "≡", + "description": "Named entity: Congruent; with a semi-colon", + "output": [ + [ + "Character", + "\u2261" + ] + ] + }, + { + "input": "&Conint", + "description": "Bad named entity: Conint without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&Conint" + ] + ] + }, + { + "input": "∯", + "description": "Named entity: Conint; with a semi-colon", + "output": [ + [ + "Character", + "\u222f" + ] + ] + }, + { + "input": "&ContourIntegral", + "description": "Bad named entity: ContourIntegral without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&ContourIntegral" + ] + ] + }, + { + "input": "∮", + "description": "Named entity: ContourIntegral; with a semi-colon", + "output": [ + [ + "Character", + "\u222e" + ] + ] + }, + { + "input": "&Copf", + "description": "Bad named entity: Copf without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&Copf" + ] + ] + }, + { + "input": "ℂ", + "description": "Named entity: Copf; with a semi-colon", + "output": [ + [ + "Character", + "\u2102" + ] + ] + }, + { + "input": "&Coproduct", + "description": "Bad named entity: Coproduct without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&Coproduct" + ] + ] + }, + { + "input": "∐", + "description": "Named entity: Coproduct; with a semi-colon", + "output": [ + [ + "Character", + "\u2210" + ] + ] + }, + { + "input": "&CounterClockwiseContourIntegral", + "description": "Bad named entity: CounterClockwiseContourIntegral without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&CounterClockwiseContourIntegral" + ] + ] + }, + { + "input": "∳", + "description": "Named entity: CounterClockwiseContourIntegral; with a semi-colon", + "output": [ + [ + "Character", + "\u2233" + ] + ] + }, + { + "input": "&Cross", + "description": "Bad named entity: Cross without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&Cross" + ] + ] + }, + { + "input": "⨯", + "description": "Named entity: Cross; with a semi-colon", + "output": [ + [ + "Character", + "\u2a2f" + ] + ] + }, + { + "input": "&Cscr", + "description": "Bad named entity: Cscr without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&Cscr" + ] + ] + }, + { + "input": "𝒞", + "description": "Named entity: Cscr; with a semi-colon", + "output": [ + [ + "Character", + "\ud835\udc9e" + ] + ] + }, + { + "input": "&Cup", + "description": "Bad named entity: Cup without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&Cup" + ] + ] + }, + { + "input": "⋓", + "description": "Named entity: Cup; with a semi-colon", + "output": [ + [ + "Character", + "\u22d3" + ] + ] + }, + { + "input": "&CupCap", + "description": "Bad named entity: CupCap without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&CupCap" + ] + ] + }, + { + "input": "≍", + "description": "Named entity: CupCap; with a semi-colon", + "output": [ + [ + "Character", + "\u224d" + ] + ] + }, + { + "input": "&DD", + "description": "Bad named entity: DD without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&DD" + ] + ] + }, + { + "input": "ⅅ", + "description": "Named entity: DD; with a semi-colon", + "output": [ + [ + "Character", + "\u2145" + ] + ] + }, + { + "input": "&DDotrahd", + "description": "Bad named entity: DDotrahd without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&DDotrahd" + ] + ] + }, + { + "input": "⤑", + "description": "Named entity: DDotrahd; with a semi-colon", + "output": [ + [ + "Character", + "\u2911" + ] + ] + }, + { + "input": "&DJcy", + "description": "Bad named entity: DJcy without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&DJcy" + ] + ] + }, + { + "input": "Ђ", + "description": "Named entity: DJcy; with a semi-colon", + "output": [ + [ + "Character", + "\u0402" + ] + ] + }, + { + "input": "&DScy", + "description": "Bad named entity: DScy without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&DScy" + ] + ] + }, + { + "input": "Ѕ", + "description": "Named entity: DScy; with a semi-colon", + "output": [ + [ + "Character", + "\u0405" + ] + ] + }, + { + "input": "&DZcy", + "description": "Bad named entity: DZcy without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&DZcy" + ] + ] + }, + { + "input": "Џ", + "description": "Named entity: DZcy; with a semi-colon", + "output": [ + [ + "Character", + "\u040f" + ] + ] + }, + { + "input": "&Dagger", + "description": "Bad named entity: Dagger without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&Dagger" + ] + ] + }, + { + "input": "‡", + "description": "Named entity: Dagger; with a semi-colon", + "output": [ + [ + "Character", + "\u2021" + ] + ] + }, + { + "input": "&Darr", + "description": "Bad named entity: Darr without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&Darr" + ] + ] + }, + { + "input": "↡", + "description": "Named entity: Darr; with a semi-colon", + "output": [ + [ + "Character", + "\u21a1" + ] + ] + }, + { + "input": "&Dashv", + "description": "Bad named entity: Dashv without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&Dashv" + ] + ] + }, + { + "input": "⫤", + "description": "Named entity: Dashv; with a semi-colon", + "output": [ + [ + "Character", + "\u2ae4" + ] + ] + }, + { + "input": "&Dcaron", + "description": "Bad named entity: Dcaron without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&Dcaron" + ] + ] + }, + { + "input": "Ď", + "description": "Named entity: Dcaron; with a semi-colon", + "output": [ + [ + "Character", + "\u010e" + ] + ] + }, + { + "input": "&Dcy", + "description": "Bad named entity: Dcy without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&Dcy" + ] + ] + }, + { + "input": "Д", + "description": "Named entity: Dcy; with a semi-colon", + "output": [ + [ + "Character", + "\u0414" + ] + ] + }, + { + "input": "&Del", + "description": "Bad named entity: Del without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&Del" + ] + ] + }, + { + "input": "∇", + "description": "Named entity: Del; with a semi-colon", + "output": [ + [ + "Character", + "\u2207" + ] + ] + }, + { + "input": "&Delta", + "description": "Bad named entity: Delta without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&Delta" + ] + ] + }, + { + "input": "Δ", + "description": "Named entity: Delta; with a semi-colon", + "output": [ + [ + "Character", + "\u0394" + ] + ] + }, + { + "input": "&Dfr", + "description": "Bad named entity: Dfr without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&Dfr" + ] + ] + }, + { + "input": "𝔇", + "description": "Named entity: Dfr; with a semi-colon", + "output": [ + [ + "Character", + "\ud835\udd07" + ] + ] + }, + { + "input": "&DiacriticalAcute", + "description": "Bad named entity: DiacriticalAcute without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&DiacriticalAcute" + ] + ] + }, + { + "input": "´", + "description": "Named entity: DiacriticalAcute; with a semi-colon", + "output": [ + [ + "Character", + "\u00b4" + ] + ] + }, + { + "input": "&DiacriticalDot", + "description": "Bad named entity: DiacriticalDot without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&DiacriticalDot" + ] + ] + }, + { + "input": "˙", + "description": "Named entity: DiacriticalDot; with a semi-colon", + "output": [ + [ + "Character", + "\u02d9" + ] + ] + }, + { + "input": "&DiacriticalDoubleAcute", + "description": "Bad named entity: DiacriticalDoubleAcute without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&DiacriticalDoubleAcute" + ] + ] + }, + { + "input": "˝", + "description": "Named entity: DiacriticalDoubleAcute; with a semi-colon", + "output": [ + [ + "Character", + "\u02dd" + ] + ] + }, + { + "input": "&DiacriticalGrave", + "description": "Bad named entity: DiacriticalGrave without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&DiacriticalGrave" + ] + ] + }, + { + "input": "`", + "description": "Named entity: DiacriticalGrave; with a semi-colon", + "output": [ + [ + "Character", + "`" + ] + ] + }, + { + "input": "&DiacriticalTilde", + "description": "Bad named entity: DiacriticalTilde without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&DiacriticalTilde" + ] + ] + }, + { + "input": "˜", + "description": "Named entity: DiacriticalTilde; with a semi-colon", + "output": [ + [ + "Character", + "\u02dc" + ] + ] + }, + { + "input": "&Diamond", + "description": "Bad named entity: Diamond without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&Diamond" + ] + ] + }, + { + "input": "⋄", + "description": "Named entity: Diamond; with a semi-colon", + "output": [ + [ + "Character", + "\u22c4" + ] + ] + }, + { + "input": "&DifferentialD", + "description": "Bad named entity: DifferentialD without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&DifferentialD" + ] + ] + }, + { + "input": "ⅆ", + "description": "Named entity: DifferentialD; with a semi-colon", + "output": [ + [ + "Character", + "\u2146" + ] + ] + }, + { + "input": "&Dopf", + "description": "Bad named entity: Dopf without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&Dopf" + ] + ] + }, + { + "input": "𝔻", + "description": "Named entity: Dopf; with a semi-colon", + "output": [ + [ + "Character", + "\ud835\udd3b" + ] + ] + }, + { + "input": "&Dot", + "description": "Bad named entity: Dot without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&Dot" + ] + ] + }, + { + "input": "¨", + "description": "Named entity: Dot; with a semi-colon", + "output": [ + [ + "Character", + "\u00a8" + ] + ] + }, + { + "input": "&DotDot", + "description": "Bad named entity: DotDot without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&DotDot" + ] + ] + }, + { + "input": "⃜", + "description": "Named entity: DotDot; with a semi-colon", + "output": [ + [ + "Character", + "\u20dc" + ] + ] + }, + { + "input": "&DotEqual", + "description": "Bad named entity: DotEqual without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&DotEqual" + ] + ] + }, + { + "input": "≐", + "description": "Named entity: DotEqual; with a semi-colon", + "output": [ + [ + "Character", + "\u2250" + ] + ] + }, + { + "input": "&DoubleContourIntegral", + "description": "Bad named entity: DoubleContourIntegral without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&DoubleContourIntegral" + ] + ] + }, + { + "input": "∯", + "description": "Named entity: DoubleContourIntegral; with a semi-colon", + "output": [ + [ + "Character", + "\u222f" + ] + ] + }, + { + "input": "&DoubleDot", + "description": "Bad named entity: DoubleDot without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&DoubleDot" + ] + ] + }, + { + "input": "¨", + "description": "Named entity: DoubleDot; with a semi-colon", + "output": [ + [ + "Character", + "\u00a8" + ] + ] + }, + { + "input": "&DoubleDownArrow", + "description": "Bad named entity: DoubleDownArrow without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&DoubleDownArrow" + ] + ] + }, + { + "input": "⇓", + "description": "Named entity: DoubleDownArrow; with a semi-colon", + "output": [ + [ + "Character", + "\u21d3" + ] + ] + }, + { + "input": "&DoubleLeftArrow", + "description": "Bad named entity: DoubleLeftArrow without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&DoubleLeftArrow" + ] + ] + }, + { + "input": "⇐", + "description": "Named entity: DoubleLeftArrow; with a semi-colon", + "output": [ + [ + "Character", + "\u21d0" + ] + ] + }, + { + "input": "&DoubleLeftRightArrow", + "description": "Bad named entity: DoubleLeftRightArrow without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&DoubleLeftRightArrow" + ] + ] + }, + { + "input": "⇔", + "description": "Named entity: DoubleLeftRightArrow; with a semi-colon", + "output": [ + [ + "Character", + "\u21d4" + ] + ] + }, + { + "input": "&DoubleLeftTee", + "description": "Bad named entity: DoubleLeftTee without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&DoubleLeftTee" + ] + ] + }, + { + "input": "⫤", + "description": "Named entity: DoubleLeftTee; with a semi-colon", + "output": [ + [ + "Character", + "\u2ae4" + ] + ] + }, + { + "input": "&DoubleLongLeftArrow", + "description": "Bad named entity: DoubleLongLeftArrow without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&DoubleLongLeftArrow" + ] + ] + }, + { + "input": "⟸", + "description": "Named entity: DoubleLongLeftArrow; with a semi-colon", + "output": [ + [ + "Character", + "\u27f8" + ] + ] + }, + { + "input": "&DoubleLongLeftRightArrow", + "description": "Bad named entity: DoubleLongLeftRightArrow without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&DoubleLongLeftRightArrow" + ] + ] + }, + { + "input": "⟺", + "description": "Named entity: DoubleLongLeftRightArrow; with a semi-colon", + "output": [ + [ + "Character", + "\u27fa" + ] + ] + }, + { + "input": "&DoubleLongRightArrow", + "description": "Bad named entity: DoubleLongRightArrow without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&DoubleLongRightArrow" + ] + ] + }, + { + "input": "⟹", + "description": "Named entity: DoubleLongRightArrow; with a semi-colon", + "output": [ + [ + "Character", + "\u27f9" + ] + ] + }, + { + "input": "&DoubleRightArrow", + "description": "Bad named entity: DoubleRightArrow without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&DoubleRightArrow" + ] + ] + }, + { + "input": "⇒", + "description": "Named entity: DoubleRightArrow; with a semi-colon", + "output": [ + [ + "Character", + "\u21d2" + ] + ] + }, + { + "input": "&DoubleRightTee", + "description": "Bad named entity: DoubleRightTee without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&DoubleRightTee" + ] + ] + }, + { + "input": "⊨", + "description": "Named entity: DoubleRightTee; with a semi-colon", + "output": [ + [ + "Character", + "\u22a8" + ] + ] + }, + { + "input": "&DoubleUpArrow", + "description": "Bad named entity: DoubleUpArrow without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&DoubleUpArrow" + ] + ] + }, + { + "input": "⇑", + "description": "Named entity: DoubleUpArrow; with a semi-colon", + "output": [ + [ + "Character", + "\u21d1" + ] + ] + }, + { + "input": "&DoubleUpDownArrow", + "description": "Bad named entity: DoubleUpDownArrow without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&DoubleUpDownArrow" + ] + ] + }, + { + "input": "⇕", + "description": "Named entity: DoubleUpDownArrow; with a semi-colon", + "output": [ + [ + "Character", + "\u21d5" + ] + ] + }, + { + "input": "&DoubleVerticalBar", + "description": "Bad named entity: DoubleVerticalBar without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&DoubleVerticalBar" + ] + ] + }, + { + "input": "∥", + "description": "Named entity: DoubleVerticalBar; with a semi-colon", + "output": [ + [ + "Character", + "\u2225" + ] + ] + }, + { + "input": "&DownArrow", + "description": "Bad named entity: DownArrow without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&DownArrow" + ] + ] + }, + { + "input": "↓", + "description": "Named entity: DownArrow; with a semi-colon", + "output": [ + [ + "Character", + "\u2193" + ] + ] + }, + { + "input": "&DownArrowBar", + "description": "Bad named entity: DownArrowBar without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&DownArrowBar" + ] + ] + }, + { + "input": "⤓", + "description": "Named entity: DownArrowBar; with a semi-colon", + "output": [ + [ + "Character", + "\u2913" + ] + ] + }, + { + "input": "&DownArrowUpArrow", + "description": "Bad named entity: DownArrowUpArrow without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&DownArrowUpArrow" + ] + ] + }, + { + "input": "⇵", + "description": "Named entity: DownArrowUpArrow; with a semi-colon", + "output": [ + [ + "Character", + "\u21f5" + ] + ] + }, + { + "input": "&DownBreve", + "description": "Bad named entity: DownBreve without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&DownBreve" + ] + ] + }, + { + "input": "̑", + "description": "Named entity: DownBreve; with a semi-colon", + "output": [ + [ + "Character", + "\u0311" + ] + ] + }, + { + "input": "&DownLeftRightVector", + "description": "Bad named entity: DownLeftRightVector without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&DownLeftRightVector" + ] + ] + }, + { + "input": "⥐", + "description": "Named entity: DownLeftRightVector; with a semi-colon", + "output": [ + [ + "Character", + "\u2950" + ] + ] + }, + { + "input": "&DownLeftTeeVector", + "description": "Bad named entity: DownLeftTeeVector without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&DownLeftTeeVector" + ] + ] + }, + { + "input": "⥞", + "description": "Named entity: DownLeftTeeVector; with a semi-colon", + "output": [ + [ + "Character", + "\u295e" + ] + ] + }, + { + "input": "&DownLeftVector", + "description": "Bad named entity: DownLeftVector without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&DownLeftVector" + ] + ] + }, + { + "input": "↽", + "description": "Named entity: DownLeftVector; with a semi-colon", + "output": [ + [ + "Character", + "\u21bd" + ] + ] + }, + { + "input": "&DownLeftVectorBar", + "description": "Bad named entity: DownLeftVectorBar without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&DownLeftVectorBar" + ] + ] + }, + { + "input": "⥖", + "description": "Named entity: DownLeftVectorBar; with a semi-colon", + "output": [ + [ + "Character", + "\u2956" + ] + ] + }, + { + "input": "&DownRightTeeVector", + "description": "Bad named entity: DownRightTeeVector without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&DownRightTeeVector" + ] + ] + }, + { + "input": "⥟", + "description": "Named entity: DownRightTeeVector; with a semi-colon", + "output": [ + [ + "Character", + "\u295f" + ] + ] + }, + { + "input": "&DownRightVector", + "description": "Bad named entity: DownRightVector without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&DownRightVector" + ] + ] + }, + { + "input": "⇁", + "description": "Named entity: DownRightVector; with a semi-colon", + "output": [ + [ + "Character", + "\u21c1" + ] + ] + }, + { + "input": "&DownRightVectorBar", + "description": "Bad named entity: DownRightVectorBar without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&DownRightVectorBar" + ] + ] + }, + { + "input": "⥗", + "description": "Named entity: DownRightVectorBar; with a semi-colon", + "output": [ + [ + "Character", + "\u2957" + ] + ] + }, + { + "input": "&DownTee", + "description": "Bad named entity: DownTee without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&DownTee" + ] + ] + }, + { + "input": "⊤", + "description": "Named entity: DownTee; with a semi-colon", + "output": [ + [ + "Character", + "\u22a4" + ] + ] + }, + { + "input": "&DownTeeArrow", + "description": "Bad named entity: DownTeeArrow without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&DownTeeArrow" + ] + ] + }, + { + "input": "↧", + "description": "Named entity: DownTeeArrow; with a semi-colon", + "output": [ + [ + "Character", + "\u21a7" + ] + ] + }, + { + "input": "&Downarrow", + "description": "Bad named entity: Downarrow without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&Downarrow" + ] + ] + }, + { + "input": "⇓", + "description": "Named entity: Downarrow; with a semi-colon", + "output": [ + [ + "Character", + "\u21d3" + ] + ] + }, + { + "input": "&Dscr", + "description": "Bad named entity: Dscr without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&Dscr" + ] + ] + }, + { + "input": "𝒟", + "description": "Named entity: Dscr; with a semi-colon", + "output": [ + [ + "Character", + "\ud835\udc9f" + ] + ] + }, + { + "input": "&Dstrok", + "description": "Bad named entity: Dstrok without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&Dstrok" + ] + ] + }, + { + "input": "Đ", + "description": "Named entity: Dstrok; with a semi-colon", + "output": [ + [ + "Character", + "\u0110" + ] + ] + }, + { + "input": "&ENG", + "description": "Bad named entity: ENG without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&ENG" + ] + ] + }, + { + "input": "Ŋ", + "description": "Named entity: ENG; with a semi-colon", + "output": [ + [ + "Character", + "\u014a" + ] + ] + }, + { + "input": "Ð", + "description": "Named entity: ETH without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "\u00d0" + ] + ] + }, + { + "input": "Ð", + "description": "Named entity: ETH; with a semi-colon", + "output": [ + [ + "Character", + "\u00d0" + ] + ] + }, + { + "input": "É", + "description": "Named entity: Eacute without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "\u00c9" + ] + ] + }, + { + "input": "É", + "description": "Named entity: Eacute; with a semi-colon", + "output": [ + [ + "Character", + "\u00c9" + ] + ] + }, + { + "input": "&Ecaron", + "description": "Bad named entity: Ecaron without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&Ecaron" + ] + ] + }, + { + "input": "Ě", + "description": "Named entity: Ecaron; with a semi-colon", + "output": [ + [ + "Character", + "\u011a" + ] + ] + }, + { + "input": "Ê", + "description": "Named entity: Ecirc without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "\u00ca" + ] + ] + }, + { + "input": "Ê", + "description": "Named entity: Ecirc; with a semi-colon", + "output": [ + [ + "Character", + "\u00ca" + ] + ] + }, + { + "input": "&Ecy", + "description": "Bad named entity: Ecy without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&Ecy" + ] + ] + }, + { + "input": "Э", + "description": "Named entity: Ecy; with a semi-colon", + "output": [ + [ + "Character", + "\u042d" + ] + ] + }, + { + "input": "&Edot", + "description": "Bad named entity: Edot without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&Edot" + ] + ] + }, + { + "input": "Ė", + "description": "Named entity: Edot; with a semi-colon", + "output": [ + [ + "Character", + "\u0116" + ] + ] + }, + { + "input": "&Efr", + "description": "Bad named entity: Efr without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&Efr" + ] + ] + }, + { + "input": "𝔈", + "description": "Named entity: Efr; with a semi-colon", + "output": [ + [ + "Character", + "\ud835\udd08" + ] + ] + }, + { + "input": "È", + "description": "Named entity: Egrave without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "\u00c8" + ] + ] + }, + { + "input": "È", + "description": "Named entity: Egrave; with a semi-colon", + "output": [ + [ + "Character", + "\u00c8" + ] + ] + }, + { + "input": "&Element", + "description": "Bad named entity: Element without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&Element" + ] + ] + }, + { + "input": "∈", + "description": "Named entity: Element; with a semi-colon", + "output": [ + [ + "Character", + "\u2208" + ] + ] + }, + { + "input": "&Emacr", + "description": "Bad named entity: Emacr without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&Emacr" + ] + ] + }, + { + "input": "Ē", + "description": "Named entity: Emacr; with a semi-colon", + "output": [ + [ + "Character", + "\u0112" + ] + ] + }, + { + "input": "&EmptySmallSquare", + "description": "Bad named entity: EmptySmallSquare without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&EmptySmallSquare" + ] + ] + }, + { + "input": "◻", + "description": "Named entity: EmptySmallSquare; with a semi-colon", + "output": [ + [ + "Character", + "\u25fb" + ] + ] + }, + { + "input": "&EmptyVerySmallSquare", + "description": "Bad named entity: EmptyVerySmallSquare without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&EmptyVerySmallSquare" + ] + ] + }, + { + "input": "▫", + "description": "Named entity: EmptyVerySmallSquare; with a semi-colon", + "output": [ + [ + "Character", + "\u25ab" + ] + ] + }, + { + "input": "&Eogon", + "description": "Bad named entity: Eogon without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&Eogon" + ] + ] + }, + { + "input": "Ę", + "description": "Named entity: Eogon; with a semi-colon", + "output": [ + [ + "Character", + "\u0118" + ] + ] + }, + { + "input": "&Eopf", + "description": "Bad named entity: Eopf without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&Eopf" + ] + ] + }, + { + "input": "𝔼", + "description": "Named entity: Eopf; with a semi-colon", + "output": [ + [ + "Character", + "\ud835\udd3c" + ] + ] + }, + { + "input": "&Epsilon", + "description": "Bad named entity: Epsilon without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&Epsilon" + ] + ] + }, + { + "input": "Ε", + "description": "Named entity: Epsilon; with a semi-colon", + "output": [ + [ + "Character", + "\u0395" + ] + ] + }, + { + "input": "&Equal", + "description": "Bad named entity: Equal without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&Equal" + ] + ] + }, + { + "input": "⩵", + "description": "Named entity: Equal; with a semi-colon", + "output": [ + [ + "Character", + "\u2a75" + ] + ] + }, + { + "input": "&EqualTilde", + "description": "Bad named entity: EqualTilde without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&EqualTilde" + ] + ] + }, + { + "input": "≂", + "description": "Named entity: EqualTilde; with a semi-colon", + "output": [ + [ + "Character", + "\u2242" + ] + ] + }, + { + "input": "&Equilibrium", + "description": "Bad named entity: Equilibrium without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&Equilibrium" + ] + ] + }, + { + "input": "⇌", + "description": "Named entity: Equilibrium; with a semi-colon", + "output": [ + [ + "Character", + "\u21cc" + ] + ] + }, + { + "input": "&Escr", + "description": "Bad named entity: Escr without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&Escr" + ] + ] + }, + { + "input": "ℰ", + "description": "Named entity: Escr; with a semi-colon", + "output": [ + [ + "Character", + "\u2130" + ] + ] + }, + { + "input": "&Esim", + "description": "Bad named entity: Esim without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&Esim" + ] + ] + }, + { + "input": "⩳", + "description": "Named entity: Esim; with a semi-colon", + "output": [ + [ + "Character", + "\u2a73" + ] + ] + }, + { + "input": "&Eta", + "description": "Bad named entity: Eta without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&Eta" + ] + ] + }, + { + "input": "Η", + "description": "Named entity: Eta; with a semi-colon", + "output": [ + [ + "Character", + "\u0397" + ] + ] + }, + { + "input": "Ë", + "description": "Named entity: Euml without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "\u00cb" + ] + ] + }, + { + "input": "Ë", + "description": "Named entity: Euml; with a semi-colon", + "output": [ + [ + "Character", + "\u00cb" + ] + ] + }, + { + "input": "&Exists", + "description": "Bad named entity: Exists without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&Exists" + ] + ] + }, + { + "input": "∃", + "description": "Named entity: Exists; with a semi-colon", + "output": [ + [ + "Character", + "\u2203" + ] + ] + }, + { + "input": "&ExponentialE", + "description": "Bad named entity: ExponentialE without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&ExponentialE" + ] + ] + }, + { + "input": "ⅇ", + "description": "Named entity: ExponentialE; with a semi-colon", + "output": [ + [ + "Character", + "\u2147" + ] + ] + }, + { + "input": "&Fcy", + "description": "Bad named entity: Fcy without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&Fcy" + ] + ] + }, + { + "input": "Ф", + "description": "Named entity: Fcy; with a semi-colon", + "output": [ + [ + "Character", + "\u0424" + ] + ] + }, + { + "input": "&Ffr", + "description": "Bad named entity: Ffr without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&Ffr" + ] + ] + }, + { + "input": "𝔉", + "description": "Named entity: Ffr; with a semi-colon", + "output": [ + [ + "Character", + "\ud835\udd09" + ] + ] + }, + { + "input": "&FilledSmallSquare", + "description": "Bad named entity: FilledSmallSquare without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&FilledSmallSquare" + ] + ] + }, + { + "input": "◼", + "description": "Named entity: FilledSmallSquare; with a semi-colon", + "output": [ + [ + "Character", + "\u25fc" + ] + ] + }, + { + "input": "&FilledVerySmallSquare", + "description": "Bad named entity: FilledVerySmallSquare without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&FilledVerySmallSquare" + ] + ] + }, + { + "input": "▪", + "description": "Named entity: FilledVerySmallSquare; with a semi-colon", + "output": [ + [ + "Character", + "\u25aa" + ] + ] + }, + { + "input": "&Fopf", + "description": "Bad named entity: Fopf without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&Fopf" + ] + ] + }, + { + "input": "𝔽", + "description": "Named entity: Fopf; with a semi-colon", + "output": [ + [ + "Character", + "\ud835\udd3d" + ] + ] + }, + { + "input": "&ForAll", + "description": "Bad named entity: ForAll without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&ForAll" + ] + ] + }, + { + "input": "∀", + "description": "Named entity: ForAll; with a semi-colon", + "output": [ + [ + "Character", + "\u2200" + ] + ] + }, + { + "input": "&Fouriertrf", + "description": "Bad named entity: Fouriertrf without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&Fouriertrf" + ] + ] + }, + { + "input": "ℱ", + "description": "Named entity: Fouriertrf; with a semi-colon", + "output": [ + [ + "Character", + "\u2131" + ] + ] + }, + { + "input": "&Fscr", + "description": "Bad named entity: Fscr without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&Fscr" + ] + ] + }, + { + "input": "ℱ", + "description": "Named entity: Fscr; with a semi-colon", + "output": [ + [ + "Character", + "\u2131" + ] + ] + }, + { + "input": "&GJcy", + "description": "Bad named entity: GJcy without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&GJcy" + ] + ] + }, + { + "input": "Ѓ", + "description": "Named entity: GJcy; with a semi-colon", + "output": [ + [ + "Character", + "\u0403" + ] + ] + }, + { + "input": ">", + "description": "Named entity: GT without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + ">" + ] + ] + }, + { + "input": ">", + "description": "Named entity: GT; with a semi-colon", + "output": [ + [ + "Character", + ">" + ] + ] + }, + { + "input": "&Gamma", + "description": "Bad named entity: Gamma without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&Gamma" + ] + ] + }, + { + "input": "Γ", + "description": "Named entity: Gamma; with a semi-colon", + "output": [ + [ + "Character", + "\u0393" + ] + ] + }, + { + "input": "&Gammad", + "description": "Bad named entity: Gammad without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&Gammad" + ] + ] + }, + { + "input": "Ϝ", + "description": "Named entity: Gammad; with a semi-colon", + "output": [ + [ + "Character", + "\u03dc" + ] + ] + }, + { + "input": "&Gbreve", + "description": "Bad named entity: Gbreve without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&Gbreve" + ] + ] + }, + { + "input": "Ğ", + "description": "Named entity: Gbreve; with a semi-colon", + "output": [ + [ + "Character", + "\u011e" + ] + ] + }, + { + "input": "&Gcedil", + "description": "Bad named entity: Gcedil without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&Gcedil" + ] + ] + }, + { + "input": "Ģ", + "description": "Named entity: Gcedil; with a semi-colon", + "output": [ + [ + "Character", + "\u0122" + ] + ] + }, + { + "input": "&Gcirc", + "description": "Bad named entity: Gcirc without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&Gcirc" + ] + ] + }, + { + "input": "Ĝ", + "description": "Named entity: Gcirc; with a semi-colon", + "output": [ + [ + "Character", + "\u011c" + ] + ] + }, + { + "input": "&Gcy", + "description": "Bad named entity: Gcy without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&Gcy" + ] + ] + }, + { + "input": "Г", + "description": "Named entity: Gcy; with a semi-colon", + "output": [ + [ + "Character", + "\u0413" + ] + ] + }, + { + "input": "&Gdot", + "description": "Bad named entity: Gdot without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&Gdot" + ] + ] + }, + { + "input": "Ġ", + "description": "Named entity: Gdot; with a semi-colon", + "output": [ + [ + "Character", + "\u0120" + ] + ] + }, + { + "input": "&Gfr", + "description": "Bad named entity: Gfr without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&Gfr" + ] + ] + }, + { + "input": "𝔊", + "description": "Named entity: Gfr; with a semi-colon", + "output": [ + [ + "Character", + "\ud835\udd0a" + ] + ] + }, + { + "input": "&Gg", + "description": "Bad named entity: Gg without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&Gg" + ] + ] + }, + { + "input": "⋙", + "description": "Named entity: Gg; with a semi-colon", + "output": [ + [ + "Character", + "\u22d9" + ] + ] + }, + { + "input": "&Gopf", + "description": "Bad named entity: Gopf without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&Gopf" + ] + ] + }, + { + "input": "𝔾", + "description": "Named entity: Gopf; with a semi-colon", + "output": [ + [ + "Character", + "\ud835\udd3e" + ] + ] + }, + { + "input": "&GreaterEqual", + "description": "Bad named entity: GreaterEqual without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&GreaterEqual" + ] + ] + }, + { + "input": "≥", + "description": "Named entity: GreaterEqual; with a semi-colon", + "output": [ + [ + "Character", + "\u2265" + ] + ] + }, + { + "input": "&GreaterEqualLess", + "description": "Bad named entity: GreaterEqualLess without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&GreaterEqualLess" + ] + ] + }, + { + "input": "⋛", + "description": "Named entity: GreaterEqualLess; with a semi-colon", + "output": [ + [ + "Character", + "\u22db" + ] + ] + }, + { + "input": "&GreaterFullEqual", + "description": "Bad named entity: GreaterFullEqual without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&GreaterFullEqual" + ] + ] + }, + { + "input": "≧", + "description": "Named entity: GreaterFullEqual; with a semi-colon", + "output": [ + [ + "Character", + "\u2267" + ] + ] + }, + { + "input": "&GreaterGreater", + "description": "Bad named entity: GreaterGreater without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&GreaterGreater" + ] + ] + }, + { + "input": "⪢", + "description": "Named entity: GreaterGreater; with a semi-colon", + "output": [ + [ + "Character", + "\u2aa2" + ] + ] + }, + { + "input": "&GreaterLess", + "description": "Bad named entity: GreaterLess without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&GreaterLess" + ] + ] + }, + { + "input": "≷", + "description": "Named entity: GreaterLess; with a semi-colon", + "output": [ + [ + "Character", + "\u2277" + ] + ] + }, + { + "input": "&GreaterSlantEqual", + "description": "Bad named entity: GreaterSlantEqual without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&GreaterSlantEqual" + ] + ] + }, + { + "input": "⩾", + "description": "Named entity: GreaterSlantEqual; with a semi-colon", + "output": [ + [ + "Character", + "\u2a7e" + ] + ] + }, + { + "input": "&GreaterTilde", + "description": "Bad named entity: GreaterTilde without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&GreaterTilde" + ] + ] + }, + { + "input": "≳", + "description": "Named entity: GreaterTilde; with a semi-colon", + "output": [ + [ + "Character", + "\u2273" + ] + ] + }, + { + "input": "&Gscr", + "description": "Bad named entity: Gscr without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&Gscr" + ] + ] + }, + { + "input": "𝒢", + "description": "Named entity: Gscr; with a semi-colon", + "output": [ + [ + "Character", + "\ud835\udca2" + ] + ] + }, + { + "input": "&Gt", + "description": "Bad named entity: Gt without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&Gt" + ] + ] + }, + { + "input": "≫", + "description": "Named entity: Gt; with a semi-colon", + "output": [ + [ + "Character", + "\u226b" + ] + ] + }, + { + "input": "&HARDcy", + "description": "Bad named entity: HARDcy without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&HARDcy" + ] + ] + }, + { + "input": "Ъ", + "description": "Named entity: HARDcy; with a semi-colon", + "output": [ + [ + "Character", + "\u042a" + ] + ] + }, + { + "input": "&Hacek", + "description": "Bad named entity: Hacek without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&Hacek" + ] + ] + }, + { + "input": "ˇ", + "description": "Named entity: Hacek; with a semi-colon", + "output": [ + [ + "Character", + "\u02c7" + ] + ] + }, + { + "input": "&Hat", + "description": "Bad named entity: Hat without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&Hat" + ] + ] + }, + { + "input": "^", + "description": "Named entity: Hat; with a semi-colon", + "output": [ + [ + "Character", + "^" + ] + ] + }, + { + "input": "&Hcirc", + "description": "Bad named entity: Hcirc without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&Hcirc" + ] + ] + }, + { + "input": "Ĥ", + "description": "Named entity: Hcirc; with a semi-colon", + "output": [ + [ + "Character", + "\u0124" + ] + ] + }, + { + "input": "&Hfr", + "description": "Bad named entity: Hfr without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&Hfr" + ] + ] + }, + { + "input": "ℌ", + "description": "Named entity: Hfr; with a semi-colon", + "output": [ + [ + "Character", + "\u210c" + ] + ] + }, + { + "input": "&HilbertSpace", + "description": "Bad named entity: HilbertSpace without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&HilbertSpace" + ] + ] + }, + { + "input": "ℋ", + "description": "Named entity: HilbertSpace; with a semi-colon", + "output": [ + [ + "Character", + "\u210b" + ] + ] + }, + { + "input": "&Hopf", + "description": "Bad named entity: Hopf without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&Hopf" + ] + ] + }, + { + "input": "ℍ", + "description": "Named entity: Hopf; with a semi-colon", + "output": [ + [ + "Character", + "\u210d" + ] + ] + }, + { + "input": "&HorizontalLine", + "description": "Bad named entity: HorizontalLine without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&HorizontalLine" + ] + ] + }, + { + "input": "─", + "description": "Named entity: HorizontalLine; with a semi-colon", + "output": [ + [ + "Character", + "\u2500" + ] + ] + }, + { + "input": "&Hscr", + "description": "Bad named entity: Hscr without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&Hscr" + ] + ] + }, + { + "input": "ℋ", + "description": "Named entity: Hscr; with a semi-colon", + "output": [ + [ + "Character", + "\u210b" + ] + ] + }, + { + "input": "&Hstrok", + "description": "Bad named entity: Hstrok without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&Hstrok" + ] + ] + }, + { + "input": "Ħ", + "description": "Named entity: Hstrok; with a semi-colon", + "output": [ + [ + "Character", + "\u0126" + ] + ] + }, + { + "input": "&HumpDownHump", + "description": "Bad named entity: HumpDownHump without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&HumpDownHump" + ] + ] + }, + { + "input": "≎", + "description": "Named entity: HumpDownHump; with a semi-colon", + "output": [ + [ + "Character", + "\u224e" + ] + ] + }, + { + "input": "&HumpEqual", + "description": "Bad named entity: HumpEqual without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&HumpEqual" + ] + ] + }, + { + "input": "≏", + "description": "Named entity: HumpEqual; with a semi-colon", + "output": [ + [ + "Character", + "\u224f" + ] + ] + }, + { + "input": "&IEcy", + "description": "Bad named entity: IEcy without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&IEcy" + ] + ] + }, + { + "input": "Е", + "description": "Named entity: IEcy; with a semi-colon", + "output": [ + [ + "Character", + "\u0415" + ] + ] + }, + { + "input": "&IJlig", + "description": "Bad named entity: IJlig without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&IJlig" + ] + ] + }, + { + "input": "IJ", + "description": "Named entity: IJlig; with a semi-colon", + "output": [ + [ + "Character", + "\u0132" + ] + ] + }, + { + "input": "&IOcy", + "description": "Bad named entity: IOcy without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&IOcy" + ] + ] + }, + { + "input": "Ё", + "description": "Named entity: IOcy; with a semi-colon", + "output": [ + [ + "Character", + "\u0401" + ] + ] + }, + { + "input": "Í", + "description": "Named entity: Iacute without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "\u00cd" + ] + ] + }, + { + "input": "Í", + "description": "Named entity: Iacute; with a semi-colon", + "output": [ + [ + "Character", + "\u00cd" + ] + ] + }, + { + "input": "Î", + "description": "Named entity: Icirc without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "\u00ce" + ] + ] + }, + { + "input": "Î", + "description": "Named entity: Icirc; with a semi-colon", + "output": [ + [ + "Character", + "\u00ce" + ] + ] + }, + { + "input": "&Icy", + "description": "Bad named entity: Icy without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&Icy" + ] + ] + }, + { + "input": "И", + "description": "Named entity: Icy; with a semi-colon", + "output": [ + [ + "Character", + "\u0418" + ] + ] + }, + { + "input": "&Idot", + "description": "Bad named entity: Idot without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&Idot" + ] + ] + }, + { + "input": "İ", + "description": "Named entity: Idot; with a semi-colon", + "output": [ + [ + "Character", + "\u0130" + ] + ] + }, + { + "input": "&Ifr", + "description": "Bad named entity: Ifr without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&Ifr" + ] + ] + }, + { + "input": "ℑ", + "description": "Named entity: Ifr; with a semi-colon", + "output": [ + [ + "Character", + "\u2111" + ] + ] + }, + { + "input": "Ì", + "description": "Named entity: Igrave without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "\u00cc" + ] + ] + }, + { + "input": "Ì", + "description": "Named entity: Igrave; with a semi-colon", + "output": [ + [ + "Character", + "\u00cc" + ] + ] + }, + { + "input": "&Im", + "description": "Bad named entity: Im without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&Im" + ] + ] + }, + { + "input": "ℑ", + "description": "Named entity: Im; with a semi-colon", + "output": [ + [ + "Character", + "\u2111" + ] + ] + }, + { + "input": "&Imacr", + "description": "Bad named entity: Imacr without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&Imacr" + ] + ] + }, + { + "input": "Ī", + "description": "Named entity: Imacr; with a semi-colon", + "output": [ + [ + "Character", + "\u012a" + ] + ] + }, + { + "input": "&ImaginaryI", + "description": "Bad named entity: ImaginaryI without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&ImaginaryI" + ] + ] + }, + { + "input": "ⅈ", + "description": "Named entity: ImaginaryI; with a semi-colon", + "output": [ + [ + "Character", + "\u2148" + ] + ] + }, + { + "input": "&Implies", + "description": "Bad named entity: Implies without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&Implies" + ] + ] + }, + { + "input": "⇒", + "description": "Named entity: Implies; with a semi-colon", + "output": [ + [ + "Character", + "\u21d2" + ] + ] + }, + { + "input": "&Int", + "description": "Bad named entity: Int without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&Int" + ] + ] + }, + { + "input": "∬", + "description": "Named entity: Int; with a semi-colon", + "output": [ + [ + "Character", + "\u222c" + ] + ] + }, + { + "input": "&Integral", + "description": "Bad named entity: Integral without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&Integral" + ] + ] + }, + { + "input": "∫", + "description": "Named entity: Integral; with a semi-colon", + "output": [ + [ + "Character", + "\u222b" + ] + ] + }, + { + "input": "&Intersection", + "description": "Bad named entity: Intersection without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&Intersection" + ] + ] + }, + { + "input": "⋂", + "description": "Named entity: Intersection; with a semi-colon", + "output": [ + [ + "Character", + "\u22c2" + ] + ] + }, + { + "input": "&InvisibleComma", + "description": "Bad named entity: InvisibleComma without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&InvisibleComma" + ] + ] + }, + { + "input": "⁣", + "description": "Named entity: InvisibleComma; with a semi-colon", + "output": [ + [ + "Character", + "\u2063" + ] + ] + }, + { + "input": "&InvisibleTimes", + "description": "Bad named entity: InvisibleTimes without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&InvisibleTimes" + ] + ] + }, + { + "input": "⁢", + "description": "Named entity: InvisibleTimes; with a semi-colon", + "output": [ + [ + "Character", + "\u2062" + ] + ] + }, + { + "input": "&Iogon", + "description": "Bad named entity: Iogon without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&Iogon" + ] + ] + }, + { + "input": "Į", + "description": "Named entity: Iogon; with a semi-colon", + "output": [ + [ + "Character", + "\u012e" + ] + ] + }, + { + "input": "&Iopf", + "description": "Bad named entity: Iopf without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&Iopf" + ] + ] + }, + { + "input": "𝕀", + "description": "Named entity: Iopf; with a semi-colon", + "output": [ + [ + "Character", + "\ud835\udd40" + ] + ] + }, + { + "input": "&Iota", + "description": "Bad named entity: Iota without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&Iota" + ] + ] + }, + { + "input": "Ι", + "description": "Named entity: Iota; with a semi-colon", + "output": [ + [ + "Character", + "\u0399" + ] + ] + }, + { + "input": "&Iscr", + "description": "Bad named entity: Iscr without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&Iscr" + ] + ] + }, + { + "input": "ℐ", + "description": "Named entity: Iscr; with a semi-colon", + "output": [ + [ + "Character", + "\u2110" + ] + ] + }, + { + "input": "&Itilde", + "description": "Bad named entity: Itilde without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&Itilde" + ] + ] + }, + { + "input": "Ĩ", + "description": "Named entity: Itilde; with a semi-colon", + "output": [ + [ + "Character", + "\u0128" + ] + ] + }, + { + "input": "&Iukcy", + "description": "Bad named entity: Iukcy without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&Iukcy" + ] + ] + }, + { + "input": "І", + "description": "Named entity: Iukcy; with a semi-colon", + "output": [ + [ + "Character", + "\u0406" + ] + ] + }, + { + "input": "Ï", + "description": "Named entity: Iuml without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "\u00cf" + ] + ] + }, + { + "input": "Ï", + "description": "Named entity: Iuml; with a semi-colon", + "output": [ + [ + "Character", + "\u00cf" + ] + ] + }, + { + "input": "&Jcirc", + "description": "Bad named entity: Jcirc without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&Jcirc" + ] + ] + }, + { + "input": "Ĵ", + "description": "Named entity: Jcirc; with a semi-colon", + "output": [ + [ + "Character", + "\u0134" + ] + ] + }, + { + "input": "&Jcy", + "description": "Bad named entity: Jcy without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&Jcy" + ] + ] + }, + { + "input": "Й", + "description": "Named entity: Jcy; with a semi-colon", + "output": [ + [ + "Character", + "\u0419" + ] + ] + }, + { + "input": "&Jfr", + "description": "Bad named entity: Jfr without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&Jfr" + ] + ] + }, + { + "input": "𝔍", + "description": "Named entity: Jfr; with a semi-colon", + "output": [ + [ + "Character", + "\ud835\udd0d" + ] + ] + }, + { + "input": "&Jopf", + "description": "Bad named entity: Jopf without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&Jopf" + ] + ] + }, + { + "input": "𝕁", + "description": "Named entity: Jopf; with a semi-colon", + "output": [ + [ + "Character", + "\ud835\udd41" + ] + ] + }, + { + "input": "&Jscr", + "description": "Bad named entity: Jscr without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&Jscr" + ] + ] + }, + { + "input": "𝒥", + "description": "Named entity: Jscr; with a semi-colon", + "output": [ + [ + "Character", + "\ud835\udca5" + ] + ] + }, + { + "input": "&Jsercy", + "description": "Bad named entity: Jsercy without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&Jsercy" + ] + ] + }, + { + "input": "Ј", + "description": "Named entity: Jsercy; with a semi-colon", + "output": [ + [ + "Character", + "\u0408" + ] + ] + }, + { + "input": "&Jukcy", + "description": "Bad named entity: Jukcy without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&Jukcy" + ] + ] + }, + { + "input": "Є", + "description": "Named entity: Jukcy; with a semi-colon", + "output": [ + [ + "Character", + "\u0404" + ] + ] + }, + { + "input": "&KHcy", + "description": "Bad named entity: KHcy without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&KHcy" + ] + ] + }, + { + "input": "Х", + "description": "Named entity: KHcy; with a semi-colon", + "output": [ + [ + "Character", + "\u0425" + ] + ] + }, + { + "input": "&KJcy", + "description": "Bad named entity: KJcy without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&KJcy" + ] + ] + }, + { + "input": "Ќ", + "description": "Named entity: KJcy; with a semi-colon", + "output": [ + [ + "Character", + "\u040c" + ] + ] + }, + { + "input": "&Kappa", + "description": "Bad named entity: Kappa without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&Kappa" + ] + ] + }, + { + "input": "Κ", + "description": "Named entity: Kappa; with a semi-colon", + "output": [ + [ + "Character", + "\u039a" + ] + ] + }, + { + "input": "&Kcedil", + "description": "Bad named entity: Kcedil without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&Kcedil" + ] + ] + }, + { + "input": "Ķ", + "description": "Named entity: Kcedil; with a semi-colon", + "output": [ + [ + "Character", + "\u0136" + ] + ] + }, + { + "input": "&Kcy", + "description": "Bad named entity: Kcy without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&Kcy" + ] + ] + }, + { + "input": "К", + "description": "Named entity: Kcy; with a semi-colon", + "output": [ + [ + "Character", + "\u041a" + ] + ] + }, + { + "input": "&Kfr", + "description": "Bad named entity: Kfr without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&Kfr" + ] + ] + }, + { + "input": "𝔎", + "description": "Named entity: Kfr; with a semi-colon", + "output": [ + [ + "Character", + "\ud835\udd0e" + ] + ] + }, + { + "input": "&Kopf", + "description": "Bad named entity: Kopf without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&Kopf" + ] + ] + }, + { + "input": "𝕂", + "description": "Named entity: Kopf; with a semi-colon", + "output": [ + [ + "Character", + "\ud835\udd42" + ] + ] + }, + { + "input": "&Kscr", + "description": "Bad named entity: Kscr without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&Kscr" + ] + ] + }, + { + "input": "𝒦", + "description": "Named entity: Kscr; with a semi-colon", + "output": [ + [ + "Character", + "\ud835\udca6" + ] + ] + }, + { + "input": "&LJcy", + "description": "Bad named entity: LJcy without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&LJcy" + ] + ] + }, + { + "input": "Љ", + "description": "Named entity: LJcy; with a semi-colon", + "output": [ + [ + "Character", + "\u0409" + ] + ] + }, + { + "input": "<", + "description": "Named entity: LT without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "<" + ] + ] + }, + { + "input": "<", + "description": "Named entity: LT; with a semi-colon", + "output": [ + [ + "Character", + "<" + ] + ] + }, + { + "input": "&Lacute", + "description": "Bad named entity: Lacute without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&Lacute" + ] + ] + }, + { + "input": "Ĺ", + "description": "Named entity: Lacute; with a semi-colon", + "output": [ + [ + "Character", + "\u0139" + ] + ] + }, + { + "input": "&Lambda", + "description": "Bad named entity: Lambda without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&Lambda" + ] + ] + }, + { + "input": "Λ", + "description": "Named entity: Lambda; with a semi-colon", + "output": [ + [ + "Character", + "\u039b" + ] + ] + }, + { + "input": "&Lang", + "description": "Bad named entity: Lang without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&Lang" + ] + ] + }, + { + "input": "⟪", + "description": "Named entity: Lang; with a semi-colon", + "output": [ + [ + "Character", + "\u27ea" + ] + ] + }, + { + "input": "&Laplacetrf", + "description": "Bad named entity: Laplacetrf without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&Laplacetrf" + ] + ] + }, + { + "input": "ℒ", + "description": "Named entity: Laplacetrf; with a semi-colon", + "output": [ + [ + "Character", + "\u2112" + ] + ] + }, + { + "input": "&Larr", + "description": "Bad named entity: Larr without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&Larr" + ] + ] + }, + { + "input": "↞", + "description": "Named entity: Larr; with a semi-colon", + "output": [ + [ + "Character", + "\u219e" + ] + ] + }, + { + "input": "&Lcaron", + "description": "Bad named entity: Lcaron without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&Lcaron" + ] + ] + }, + { + "input": "Ľ", + "description": "Named entity: Lcaron; with a semi-colon", + "output": [ + [ + "Character", + "\u013d" + ] + ] + }, + { + "input": "&Lcedil", + "description": "Bad named entity: Lcedil without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&Lcedil" + ] + ] + }, + { + "input": "Ļ", + "description": "Named entity: Lcedil; with a semi-colon", + "output": [ + [ + "Character", + "\u013b" + ] + ] + }, + { + "input": "&Lcy", + "description": "Bad named entity: Lcy without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&Lcy" + ] + ] + }, + { + "input": "Л", + "description": "Named entity: Lcy; with a semi-colon", + "output": [ + [ + "Character", + "\u041b" + ] + ] + }, + { + "input": "&LeftAngleBracket", + "description": "Bad named entity: LeftAngleBracket without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&LeftAngleBracket" + ] + ] + }, + { + "input": "⟨", + "description": "Named entity: LeftAngleBracket; with a semi-colon", + "output": [ + [ + "Character", + "\u27e8" + ] + ] + }, + { + "input": "&LeftArrow", + "description": "Bad named entity: LeftArrow without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&LeftArrow" + ] + ] + }, + { + "input": "←", + "description": "Named entity: LeftArrow; with a semi-colon", + "output": [ + [ + "Character", + "\u2190" + ] + ] + }, + { + "input": "&LeftArrowBar", + "description": "Bad named entity: LeftArrowBar without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&LeftArrowBar" + ] + ] + }, + { + "input": "⇤", + "description": "Named entity: LeftArrowBar; with a semi-colon", + "output": [ + [ + "Character", + "\u21e4" + ] + ] + }, + { + "input": "&LeftArrowRightArrow", + "description": "Bad named entity: LeftArrowRightArrow without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&LeftArrowRightArrow" + ] + ] + }, + { + "input": "⇆", + "description": "Named entity: LeftArrowRightArrow; with a semi-colon", + "output": [ + [ + "Character", + "\u21c6" + ] + ] + }, + { + "input": "&LeftCeiling", + "description": "Bad named entity: LeftCeiling without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&LeftCeiling" + ] + ] + }, + { + "input": "⌈", + "description": "Named entity: LeftCeiling; with a semi-colon", + "output": [ + [ + "Character", + "\u2308" + ] + ] + }, + { + "input": "&LeftDoubleBracket", + "description": "Bad named entity: LeftDoubleBracket without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&LeftDoubleBracket" + ] + ] + }, + { + "input": "⟦", + "description": "Named entity: LeftDoubleBracket; with a semi-colon", + "output": [ + [ + "Character", + "\u27e6" + ] + ] + }, + { + "input": "&LeftDownTeeVector", + "description": "Bad named entity: LeftDownTeeVector without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&LeftDownTeeVector" + ] + ] + }, + { + "input": "⥡", + "description": "Named entity: LeftDownTeeVector; with a semi-colon", + "output": [ + [ + "Character", + "\u2961" + ] + ] + }, + { + "input": "&LeftDownVector", + "description": "Bad named entity: LeftDownVector without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&LeftDownVector" + ] + ] + }, + { + "input": "⇃", + "description": "Named entity: LeftDownVector; with a semi-colon", + "output": [ + [ + "Character", + "\u21c3" + ] + ] + }, + { + "input": "&LeftDownVectorBar", + "description": "Bad named entity: LeftDownVectorBar without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&LeftDownVectorBar" + ] + ] + }, + { + "input": "⥙", + "description": "Named entity: LeftDownVectorBar; with a semi-colon", + "output": [ + [ + "Character", + "\u2959" + ] + ] + }, + { + "input": "&LeftFloor", + "description": "Bad named entity: LeftFloor without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&LeftFloor" + ] + ] + }, + { + "input": "⌊", + "description": "Named entity: LeftFloor; with a semi-colon", + "output": [ + [ + "Character", + "\u230a" + ] + ] + }, + { + "input": "&LeftRightArrow", + "description": "Bad named entity: LeftRightArrow without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&LeftRightArrow" + ] + ] + }, + { + "input": "↔", + "description": "Named entity: LeftRightArrow; with a semi-colon", + "output": [ + [ + "Character", + "\u2194" + ] + ] + }, + { + "input": "&LeftRightVector", + "description": "Bad named entity: LeftRightVector without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&LeftRightVector" + ] + ] + }, + { + "input": "⥎", + "description": "Named entity: LeftRightVector; with a semi-colon", + "output": [ + [ + "Character", + "\u294e" + ] + ] + }, + { + "input": "&LeftTee", + "description": "Bad named entity: LeftTee without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&LeftTee" + ] + ] + }, + { + "input": "⊣", + "description": "Named entity: LeftTee; with a semi-colon", + "output": [ + [ + "Character", + "\u22a3" + ] + ] + }, + { + "input": "&LeftTeeArrow", + "description": "Bad named entity: LeftTeeArrow without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&LeftTeeArrow" + ] + ] + }, + { + "input": "↤", + "description": "Named entity: LeftTeeArrow; with a semi-colon", + "output": [ + [ + "Character", + "\u21a4" + ] + ] + }, + { + "input": "&LeftTeeVector", + "description": "Bad named entity: LeftTeeVector without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&LeftTeeVector" + ] + ] + }, + { + "input": "⥚", + "description": "Named entity: LeftTeeVector; with a semi-colon", + "output": [ + [ + "Character", + "\u295a" + ] + ] + }, + { + "input": "&LeftTriangle", + "description": "Bad named entity: LeftTriangle without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&LeftTriangle" + ] + ] + }, + { + "input": "⊲", + "description": "Named entity: LeftTriangle; with a semi-colon", + "output": [ + [ + "Character", + "\u22b2" + ] + ] + }, + { + "input": "&LeftTriangleBar", + "description": "Bad named entity: LeftTriangleBar without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&LeftTriangleBar" + ] + ] + }, + { + "input": "⧏", + "description": "Named entity: LeftTriangleBar; with a semi-colon", + "output": [ + [ + "Character", + "\u29cf" + ] + ] + }, + { + "input": "&LeftTriangleEqual", + "description": "Bad named entity: LeftTriangleEqual without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&LeftTriangleEqual" + ] + ] + }, + { + "input": "⊴", + "description": "Named entity: LeftTriangleEqual; with a semi-colon", + "output": [ + [ + "Character", + "\u22b4" + ] + ] + }, + { + "input": "&LeftUpDownVector", + "description": "Bad named entity: LeftUpDownVector without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&LeftUpDownVector" + ] + ] + }, + { + "input": "⥑", + "description": "Named entity: LeftUpDownVector; with a semi-colon", + "output": [ + [ + "Character", + "\u2951" + ] + ] + }, + { + "input": "&LeftUpTeeVector", + "description": "Bad named entity: LeftUpTeeVector without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&LeftUpTeeVector" + ] + ] + }, + { + "input": "⥠", + "description": "Named entity: LeftUpTeeVector; with a semi-colon", + "output": [ + [ + "Character", + "\u2960" + ] + ] + }, + { + "input": "&LeftUpVector", + "description": "Bad named entity: LeftUpVector without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&LeftUpVector" + ] + ] + }, + { + "input": "↿", + "description": "Named entity: LeftUpVector; with a semi-colon", + "output": [ + [ + "Character", + "\u21bf" + ] + ] + }, + { + "input": "&LeftUpVectorBar", + "description": "Bad named entity: LeftUpVectorBar without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&LeftUpVectorBar" + ] + ] + }, + { + "input": "⥘", + "description": "Named entity: LeftUpVectorBar; with a semi-colon", + "output": [ + [ + "Character", + "\u2958" + ] + ] + }, + { + "input": "&LeftVector", + "description": "Bad named entity: LeftVector without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&LeftVector" + ] + ] + }, + { + "input": "↼", + "description": "Named entity: LeftVector; with a semi-colon", + "output": [ + [ + "Character", + "\u21bc" + ] + ] + }, + { + "input": "&LeftVectorBar", + "description": "Bad named entity: LeftVectorBar without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&LeftVectorBar" + ] + ] + }, + { + "input": "⥒", + "description": "Named entity: LeftVectorBar; with a semi-colon", + "output": [ + [ + "Character", + "\u2952" + ] + ] + }, + { + "input": "&Leftarrow", + "description": "Bad named entity: Leftarrow without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&Leftarrow" + ] + ] + }, + { + "input": "⇐", + "description": "Named entity: Leftarrow; with a semi-colon", + "output": [ + [ + "Character", + "\u21d0" + ] + ] + }, + { + "input": "&Leftrightarrow", + "description": "Bad named entity: Leftrightarrow without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&Leftrightarrow" + ] + ] + }, + { + "input": "⇔", + "description": "Named entity: Leftrightarrow; with a semi-colon", + "output": [ + [ + "Character", + "\u21d4" + ] + ] + }, + { + "input": "&LessEqualGreater", + "description": "Bad named entity: LessEqualGreater without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&LessEqualGreater" + ] + ] + }, + { + "input": "⋚", + "description": "Named entity: LessEqualGreater; with a semi-colon", + "output": [ + [ + "Character", + "\u22da" + ] + ] + }, + { + "input": "&LessFullEqual", + "description": "Bad named entity: LessFullEqual without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&LessFullEqual" + ] + ] + }, + { + "input": "≦", + "description": "Named entity: LessFullEqual; with a semi-colon", + "output": [ + [ + "Character", + "\u2266" + ] + ] + }, + { + "input": "&LessGreater", + "description": "Bad named entity: LessGreater without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&LessGreater" + ] + ] + }, + { + "input": "≶", + "description": "Named entity: LessGreater; with a semi-colon", + "output": [ + [ + "Character", + "\u2276" + ] + ] + }, + { + "input": "&LessLess", + "description": "Bad named entity: LessLess without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&LessLess" + ] + ] + }, + { + "input": "⪡", + "description": "Named entity: LessLess; with a semi-colon", + "output": [ + [ + "Character", + "\u2aa1" + ] + ] + }, + { + "input": "&LessSlantEqual", + "description": "Bad named entity: LessSlantEqual without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&LessSlantEqual" + ] + ] + }, + { + "input": "⩽", + "description": "Named entity: LessSlantEqual; with a semi-colon", + "output": [ + [ + "Character", + "\u2a7d" + ] + ] + }, + { + "input": "&LessTilde", + "description": "Bad named entity: LessTilde without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&LessTilde" + ] + ] + }, + { + "input": "≲", + "description": "Named entity: LessTilde; with a semi-colon", + "output": [ + [ + "Character", + "\u2272" + ] + ] + }, + { + "input": "&Lfr", + "description": "Bad named entity: Lfr without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&Lfr" + ] + ] + }, + { + "input": "𝔏", + "description": "Named entity: Lfr; with a semi-colon", + "output": [ + [ + "Character", + "\ud835\udd0f" + ] + ] + }, + { + "input": "&Ll", + "description": "Bad named entity: Ll without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&Ll" + ] + ] + }, + { + "input": "⋘", + "description": "Named entity: Ll; with a semi-colon", + "output": [ + [ + "Character", + "\u22d8" + ] + ] + }, + { + "input": "&Lleftarrow", + "description": "Bad named entity: Lleftarrow without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&Lleftarrow" + ] + ] + }, + { + "input": "⇚", + "description": "Named entity: Lleftarrow; with a semi-colon", + "output": [ + [ + "Character", + "\u21da" + ] + ] + }, + { + "input": "&Lmidot", + "description": "Bad named entity: Lmidot without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&Lmidot" + ] + ] + }, + { + "input": "Ŀ", + "description": "Named entity: Lmidot; with a semi-colon", + "output": [ + [ + "Character", + "\u013f" + ] + ] + }, + { + "input": "&LongLeftArrow", + "description": "Bad named entity: LongLeftArrow without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&LongLeftArrow" + ] + ] + }, + { + "input": "⟵", + "description": "Named entity: LongLeftArrow; with a semi-colon", + "output": [ + [ + "Character", + "\u27f5" + ] + ] + }, + { + "input": "&LongLeftRightArrow", + "description": "Bad named entity: LongLeftRightArrow without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&LongLeftRightArrow" + ] + ] + }, + { + "input": "⟷", + "description": "Named entity: LongLeftRightArrow; with a semi-colon", + "output": [ + [ + "Character", + "\u27f7" + ] + ] + }, + { + "input": "&LongRightArrow", + "description": "Bad named entity: LongRightArrow without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&LongRightArrow" + ] + ] + }, + { + "input": "⟶", + "description": "Named entity: LongRightArrow; with a semi-colon", + "output": [ + [ + "Character", + "\u27f6" + ] + ] + }, + { + "input": "&Longleftarrow", + "description": "Bad named entity: Longleftarrow without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&Longleftarrow" + ] + ] + }, + { + "input": "⟸", + "description": "Named entity: Longleftarrow; with a semi-colon", + "output": [ + [ + "Character", + "\u27f8" + ] + ] + }, + { + "input": "&Longleftrightarrow", + "description": "Bad named entity: Longleftrightarrow without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&Longleftrightarrow" + ] + ] + }, + { + "input": "⟺", + "description": "Named entity: Longleftrightarrow; with a semi-colon", + "output": [ + [ + "Character", + "\u27fa" + ] + ] + }, + { + "input": "&Longrightarrow", + "description": "Bad named entity: Longrightarrow without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&Longrightarrow" + ] + ] + }, + { + "input": "⟹", + "description": "Named entity: Longrightarrow; with a semi-colon", + "output": [ + [ + "Character", + "\u27f9" + ] + ] + }, + { + "input": "&Lopf", + "description": "Bad named entity: Lopf without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&Lopf" + ] + ] + }, + { + "input": "𝕃", + "description": "Named entity: Lopf; with a semi-colon", + "output": [ + [ + "Character", + "\ud835\udd43" + ] + ] + }, + { + "input": "&LowerLeftArrow", + "description": "Bad named entity: LowerLeftArrow without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&LowerLeftArrow" + ] + ] + }, + { + "input": "↙", + "description": "Named entity: LowerLeftArrow; with a semi-colon", + "output": [ + [ + "Character", + "\u2199" + ] + ] + }, + { + "input": "&LowerRightArrow", + "description": "Bad named entity: LowerRightArrow without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&LowerRightArrow" + ] + ] + }, + { + "input": "↘", + "description": "Named entity: LowerRightArrow; with a semi-colon", + "output": [ + [ + "Character", + "\u2198" + ] + ] + }, + { + "input": "&Lscr", + "description": "Bad named entity: Lscr without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&Lscr" + ] + ] + }, + { + "input": "ℒ", + "description": "Named entity: Lscr; with a semi-colon", + "output": [ + [ + "Character", + "\u2112" + ] + ] + }, + { + "input": "&Lsh", + "description": "Bad named entity: Lsh without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&Lsh" + ] + ] + }, + { + "input": "↰", + "description": "Named entity: Lsh; with a semi-colon", + "output": [ + [ + "Character", + "\u21b0" + ] + ] + }, + { + "input": "&Lstrok", + "description": "Bad named entity: Lstrok without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&Lstrok" + ] + ] + }, + { + "input": "Ł", + "description": "Named entity: Lstrok; with a semi-colon", + "output": [ + [ + "Character", + "\u0141" + ] + ] + }, + { + "input": "&Lt", + "description": "Bad named entity: Lt without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&Lt" + ] + ] + }, + { + "input": "≪", + "description": "Named entity: Lt; with a semi-colon", + "output": [ + [ + "Character", + "\u226a" + ] + ] + }, + { + "input": "&Map", + "description": "Bad named entity: Map without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&Map" + ] + ] + }, + { + "input": "⤅", + "description": "Named entity: Map; with a semi-colon", + "output": [ + [ + "Character", + "\u2905" + ] + ] + }, + { + "input": "&Mcy", + "description": "Bad named entity: Mcy without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&Mcy" + ] + ] + }, + { + "input": "М", + "description": "Named entity: Mcy; with a semi-colon", + "output": [ + [ + "Character", + "\u041c" + ] + ] + }, + { + "input": "&MediumSpace", + "description": "Bad named entity: MediumSpace without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&MediumSpace" + ] + ] + }, + { + "input": " ", + "description": "Named entity: MediumSpace; with a semi-colon", + "output": [ + [ + "Character", + "\u205f" + ] + ] + }, + { + "input": "&Mellintrf", + "description": "Bad named entity: Mellintrf without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&Mellintrf" + ] + ] + }, + { + "input": "ℳ", + "description": "Named entity: Mellintrf; with a semi-colon", + "output": [ + [ + "Character", + "\u2133" + ] + ] + }, + { + "input": "&Mfr", + "description": "Bad named entity: Mfr without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&Mfr" + ] + ] + }, + { + "input": "𝔐", + "description": "Named entity: Mfr; with a semi-colon", + "output": [ + [ + "Character", + "\ud835\udd10" + ] + ] + }, + { + "input": "&MinusPlus", + "description": "Bad named entity: MinusPlus without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&MinusPlus" + ] + ] + }, + { + "input": "∓", + "description": "Named entity: MinusPlus; with a semi-colon", + "output": [ + [ + "Character", + "\u2213" + ] + ] + }, + { + "input": "&Mopf", + "description": "Bad named entity: Mopf without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&Mopf" + ] + ] + }, + { + "input": "𝕄", + "description": "Named entity: Mopf; with a semi-colon", + "output": [ + [ + "Character", + "\ud835\udd44" + ] + ] + }, + { + "input": "&Mscr", + "description": "Bad named entity: Mscr without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&Mscr" + ] + ] + }, + { + "input": "ℳ", + "description": "Named entity: Mscr; with a semi-colon", + "output": [ + [ + "Character", + "\u2133" + ] + ] + }, + { + "input": "&Mu", + "description": "Bad named entity: Mu without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&Mu" + ] + ] + }, + { + "input": "Μ", + "description": "Named entity: Mu; with a semi-colon", + "output": [ + [ + "Character", + "\u039c" + ] + ] + }, + { + "input": "&NJcy", + "description": "Bad named entity: NJcy without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&NJcy" + ] + ] + }, + { + "input": "Њ", + "description": "Named entity: NJcy; with a semi-colon", + "output": [ + [ + "Character", + "\u040a" + ] + ] + }, + { + "input": "&Nacute", + "description": "Bad named entity: Nacute without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&Nacute" + ] + ] + }, + { + "input": "Ń", + "description": "Named entity: Nacute; with a semi-colon", + "output": [ + [ + "Character", + "\u0143" + ] + ] + }, + { + "input": "&Ncaron", + "description": "Bad named entity: Ncaron without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&Ncaron" + ] + ] + }, + { + "input": "Ň", + "description": "Named entity: Ncaron; with a semi-colon", + "output": [ + [ + "Character", + "\u0147" + ] + ] + }, + { + "input": "&Ncedil", + "description": "Bad named entity: Ncedil without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&Ncedil" + ] + ] + }, + { + "input": "Ņ", + "description": "Named entity: Ncedil; with a semi-colon", + "output": [ + [ + "Character", + "\u0145" + ] + ] + }, + { + "input": "&Ncy", + "description": "Bad named entity: Ncy without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&Ncy" + ] + ] + }, + { + "input": "Н", + "description": "Named entity: Ncy; with a semi-colon", + "output": [ + [ + "Character", + "\u041d" + ] + ] + }, + { + "input": "&NegativeMediumSpace", + "description": "Bad named entity: NegativeMediumSpace without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&NegativeMediumSpace" + ] + ] + }, + { + "input": "​", + "description": "Named entity: NegativeMediumSpace; with a semi-colon", + "output": [ + [ + "Character", + "\u200b" + ] + ] + }, + { + "input": "&NegativeThickSpace", + "description": "Bad named entity: NegativeThickSpace without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&NegativeThickSpace" + ] + ] + }, + { + "input": "​", + "description": "Named entity: NegativeThickSpace; with a semi-colon", + "output": [ + [ + "Character", + "\u200b" + ] + ] + }, + { + "input": "&NegativeThinSpace", + "description": "Bad named entity: NegativeThinSpace without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&NegativeThinSpace" + ] + ] + }, + { + "input": "​", + "description": "Named entity: NegativeThinSpace; with a semi-colon", + "output": [ + [ + "Character", + "\u200b" + ] + ] + }, + { + "input": "&NegativeVeryThinSpace", + "description": "Bad named entity: NegativeVeryThinSpace without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&NegativeVeryThinSpace" + ] + ] + }, + { + "input": "​", + "description": "Named entity: NegativeVeryThinSpace; with a semi-colon", + "output": [ + [ + "Character", + "\u200b" + ] + ] + }, + { + "input": "&NestedGreaterGreater", + "description": "Bad named entity: NestedGreaterGreater without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&NestedGreaterGreater" + ] + ] + }, + { + "input": "≫", + "description": "Named entity: NestedGreaterGreater; with a semi-colon", + "output": [ + [ + "Character", + "\u226b" + ] + ] + }, + { + "input": "&NestedLessLess", + "description": "Bad named entity: NestedLessLess without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&NestedLessLess" + ] + ] + }, + { + "input": "≪", + "description": "Named entity: NestedLessLess; with a semi-colon", + "output": [ + [ + "Character", + "\u226a" + ] + ] + }, + { + "input": "&NewLine", + "description": "Bad named entity: NewLine without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&NewLine" + ] + ] + }, + { + "input": " ", + "description": "Named entity: NewLine; with a semi-colon", + "output": [ + [ + "Character", + "\n" + ] + ] + }, + { + "input": "&Nfr", + "description": "Bad named entity: Nfr without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&Nfr" + ] + ] + }, + { + "input": "𝔑", + "description": "Named entity: Nfr; with a semi-colon", + "output": [ + [ + "Character", + "\ud835\udd11" + ] + ] + }, + { + "input": "&NoBreak", + "description": "Bad named entity: NoBreak without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&NoBreak" + ] + ] + }, + { + "input": "⁠", + "description": "Named entity: NoBreak; with a semi-colon", + "output": [ + [ + "Character", + "\u2060" + ] + ] + }, + { + "input": "&NonBreakingSpace", + "description": "Bad named entity: NonBreakingSpace without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&NonBreakingSpace" + ] + ] + }, + { + "input": " ", + "description": "Named entity: NonBreakingSpace; with a semi-colon", + "output": [ + [ + "Character", + "\u00a0" + ] + ] + }, + { + "input": "&Nopf", + "description": "Bad named entity: Nopf without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&Nopf" + ] + ] + }, + { + "input": "ℕ", + "description": "Named entity: Nopf; with a semi-colon", + "output": [ + [ + "Character", + "\u2115" + ] + ] + }, + { + "input": "&Not", + "description": "Bad named entity: Not without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&Not" + ] + ] + }, + { + "input": "⫬", + "description": "Named entity: Not; with a semi-colon", + "output": [ + [ + "Character", + "\u2aec" + ] + ] + }, + { + "input": "&NotCongruent", + "description": "Bad named entity: NotCongruent without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&NotCongruent" + ] + ] + }, + { + "input": "≢", + "description": "Named entity: NotCongruent; with a semi-colon", + "output": [ + [ + "Character", + "\u2262" + ] + ] + }, + { + "input": "&NotCupCap", + "description": "Bad named entity: NotCupCap without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&NotCupCap" + ] + ] + }, + { + "input": "≭", + "description": "Named entity: NotCupCap; with a semi-colon", + "output": [ + [ + "Character", + "\u226d" + ] + ] + }, + { + "input": "&NotDoubleVerticalBar", + "description": "Bad named entity: NotDoubleVerticalBar without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&NotDoubleVerticalBar" + ] + ] + }, + { + "input": "∦", + "description": "Named entity: NotDoubleVerticalBar; with a semi-colon", + "output": [ + [ + "Character", + "\u2226" + ] + ] + }, + { + "input": "&NotElement", + "description": "Bad named entity: NotElement without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&NotElement" + ] + ] + }, + { + "input": "∉", + "description": "Named entity: NotElement; with a semi-colon", + "output": [ + [ + "Character", + "\u2209" + ] + ] + }, + { + "input": "&NotEqual", + "description": "Bad named entity: NotEqual without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&NotEqual" + ] + ] + }, + { + "input": "≠", + "description": "Named entity: NotEqual; with a semi-colon", + "output": [ + [ + "Character", + "\u2260" + ] + ] + }, + { + "input": "&NotEqualTilde", + "description": "Bad named entity: NotEqualTilde without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&NotEqualTilde" + ] + ] + }, + { + "input": "≂̸", + "description": "Named entity: NotEqualTilde; with a semi-colon", + "output": [ + [ + "Character", + "\u2242\u0338" + ] + ] + }, + { + "input": "&NotExists", + "description": "Bad named entity: NotExists without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&NotExists" + ] + ] + }, + { + "input": "∄", + "description": "Named entity: NotExists; with a semi-colon", + "output": [ + [ + "Character", + "\u2204" + ] + ] + }, + { + "input": "&NotGreater", + "description": "Bad named entity: NotGreater without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&NotGreater" + ] + ] + }, + { + "input": "≯", + "description": "Named entity: NotGreater; with a semi-colon", + "output": [ + [ + "Character", + "\u226f" + ] + ] + }, + { + "input": "&NotGreaterEqual", + "description": "Bad named entity: NotGreaterEqual without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&NotGreaterEqual" + ] + ] + }, + { + "input": "≱", + "description": "Named entity: NotGreaterEqual; with a semi-colon", + "output": [ + [ + "Character", + "\u2271" + ] + ] + }, + { + "input": "&NotGreaterFullEqual", + "description": "Bad named entity: NotGreaterFullEqual without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&NotGreaterFullEqual" + ] + ] + }, + { + "input": "≧̸", + "description": "Named entity: NotGreaterFullEqual; with a semi-colon", + "output": [ + [ + "Character", + "\u2267\u0338" + ] + ] + }, + { + "input": "&NotGreaterGreater", + "description": "Bad named entity: NotGreaterGreater without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&NotGreaterGreater" + ] + ] + }, + { + "input": "≫̸", + "description": "Named entity: NotGreaterGreater; with a semi-colon", + "output": [ + [ + "Character", + "\u226b\u0338" + ] + ] + }, + { + "input": "&NotGreaterLess", + "description": "Bad named entity: NotGreaterLess without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&NotGreaterLess" + ] + ] + }, + { + "input": "≹", + "description": "Named entity: NotGreaterLess; with a semi-colon", + "output": [ + [ + "Character", + "\u2279" + ] + ] + }, + { + "input": "&NotGreaterSlantEqual", + "description": "Bad named entity: NotGreaterSlantEqual without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&NotGreaterSlantEqual" + ] + ] + }, + { + "input": "⩾̸", + "description": "Named entity: NotGreaterSlantEqual; with a semi-colon", + "output": [ + [ + "Character", + "\u2a7e\u0338" + ] + ] + }, + { + "input": "&NotGreaterTilde", + "description": "Bad named entity: NotGreaterTilde without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&NotGreaterTilde" + ] + ] + }, + { + "input": "≵", + "description": "Named entity: NotGreaterTilde; with a semi-colon", + "output": [ + [ + "Character", + "\u2275" + ] + ] + }, + { + "input": "&NotHumpDownHump", + "description": "Bad named entity: NotHumpDownHump without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&NotHumpDownHump" + ] + ] + }, + { + "input": "≎̸", + "description": "Named entity: NotHumpDownHump; with a semi-colon", + "output": [ + [ + "Character", + "\u224e\u0338" + ] + ] + }, + { + "input": "&NotHumpEqual", + "description": "Bad named entity: NotHumpEqual without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&NotHumpEqual" + ] + ] + }, + { + "input": "≏̸", + "description": "Named entity: NotHumpEqual; with a semi-colon", + "output": [ + [ + "Character", + "\u224f\u0338" + ] + ] + }, + { + "input": "&NotLeftTriangle", + "description": "Bad named entity: NotLeftTriangle without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&NotLeftTriangle" + ] + ] + }, + { + "input": "⋪", + "description": "Named entity: NotLeftTriangle; with a semi-colon", + "output": [ + [ + "Character", + "\u22ea" + ] + ] + }, + { + "input": "&NotLeftTriangleBar", + "description": "Bad named entity: NotLeftTriangleBar without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&NotLeftTriangleBar" + ] + ] + }, + { + "input": "⧏̸", + "description": "Named entity: NotLeftTriangleBar; with a semi-colon", + "output": [ + [ + "Character", + "\u29cf\u0338" + ] + ] + }, + { + "input": "&NotLeftTriangleEqual", + "description": "Bad named entity: NotLeftTriangleEqual without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&NotLeftTriangleEqual" + ] + ] + }, + { + "input": "⋬", + "description": "Named entity: NotLeftTriangleEqual; with a semi-colon", + "output": [ + [ + "Character", + "\u22ec" + ] + ] + }, + { + "input": "&NotLess", + "description": "Bad named entity: NotLess without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&NotLess" + ] + ] + }, + { + "input": "≮", + "description": "Named entity: NotLess; with a semi-colon", + "output": [ + [ + "Character", + "\u226e" + ] + ] + }, + { + "input": "&NotLessEqual", + "description": "Bad named entity: NotLessEqual without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&NotLessEqual" + ] + ] + }, + { + "input": "≰", + "description": "Named entity: NotLessEqual; with a semi-colon", + "output": [ + [ + "Character", + "\u2270" + ] + ] + }, + { + "input": "&NotLessGreater", + "description": "Bad named entity: NotLessGreater without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&NotLessGreater" + ] + ] + }, + { + "input": "≸", + "description": "Named entity: NotLessGreater; with a semi-colon", + "output": [ + [ + "Character", + "\u2278" + ] + ] + }, + { + "input": "&NotLessLess", + "description": "Bad named entity: NotLessLess without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&NotLessLess" + ] + ] + }, + { + "input": "≪̸", + "description": "Named entity: NotLessLess; with a semi-colon", + "output": [ + [ + "Character", + "\u226a\u0338" + ] + ] + }, + { + "input": "&NotLessSlantEqual", + "description": "Bad named entity: NotLessSlantEqual without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&NotLessSlantEqual" + ] + ] + }, + { + "input": "⩽̸", + "description": "Named entity: NotLessSlantEqual; with a semi-colon", + "output": [ + [ + "Character", + "\u2a7d\u0338" + ] + ] + }, + { + "input": "&NotLessTilde", + "description": "Bad named entity: NotLessTilde without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&NotLessTilde" + ] + ] + }, + { + "input": "≴", + "description": "Named entity: NotLessTilde; with a semi-colon", + "output": [ + [ + "Character", + "\u2274" + ] + ] + }, + { + "input": "&NotNestedGreaterGreater", + "description": "Bad named entity: NotNestedGreaterGreater without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&NotNestedGreaterGreater" + ] + ] + }, + { + "input": "⪢̸", + "description": "Named entity: NotNestedGreaterGreater; with a semi-colon", + "output": [ + [ + "Character", + "\u2aa2\u0338" + ] + ] + }, + { + "input": "&NotNestedLessLess", + "description": "Bad named entity: NotNestedLessLess without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&NotNestedLessLess" + ] + ] + }, + { + "input": "⪡̸", + "description": "Named entity: NotNestedLessLess; with a semi-colon", + "output": [ + [ + "Character", + "\u2aa1\u0338" + ] + ] + }, + { + "input": "&NotPrecedes", + "description": "Bad named entity: NotPrecedes without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&NotPrecedes" + ] + ] + }, + { + "input": "⊀", + "description": "Named entity: NotPrecedes; with a semi-colon", + "output": [ + [ + "Character", + "\u2280" + ] + ] + }, + { + "input": "&NotPrecedesEqual", + "description": "Bad named entity: NotPrecedesEqual without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&NotPrecedesEqual" + ] + ] + }, + { + "input": "⪯̸", + "description": "Named entity: NotPrecedesEqual; with a semi-colon", + "output": [ + [ + "Character", + "\u2aaf\u0338" + ] + ] + }, + { + "input": "&NotPrecedesSlantEqual", + "description": "Bad named entity: NotPrecedesSlantEqual without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&NotPrecedesSlantEqual" + ] + ] + }, + { + "input": "⋠", + "description": "Named entity: NotPrecedesSlantEqual; with a semi-colon", + "output": [ + [ + "Character", + "\u22e0" + ] + ] + }, + { + "input": "&NotReverseElement", + "description": "Bad named entity: NotReverseElement without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&NotReverseElement" + ] + ] + }, + { + "input": "∌", + "description": "Named entity: NotReverseElement; with a semi-colon", + "output": [ + [ + "Character", + "\u220c" + ] + ] + }, + { + "input": "&NotRightTriangle", + "description": "Bad named entity: NotRightTriangle without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&NotRightTriangle" + ] + ] + }, + { + "input": "⋫", + "description": "Named entity: NotRightTriangle; with a semi-colon", + "output": [ + [ + "Character", + "\u22eb" + ] + ] + }, + { + "input": "&NotRightTriangleBar", + "description": "Bad named entity: NotRightTriangleBar without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&NotRightTriangleBar" + ] + ] + }, + { + "input": "⧐̸", + "description": "Named entity: NotRightTriangleBar; with a semi-colon", + "output": [ + [ + "Character", + "\u29d0\u0338" + ] + ] + }, + { + "input": "&NotRightTriangleEqual", + "description": "Bad named entity: NotRightTriangleEqual without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&NotRightTriangleEqual" + ] + ] + }, + { + "input": "⋭", + "description": "Named entity: NotRightTriangleEqual; with a semi-colon", + "output": [ + [ + "Character", + "\u22ed" + ] + ] + }, + { + "input": "&NotSquareSubset", + "description": "Bad named entity: NotSquareSubset without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&NotSquareSubset" + ] + ] + }, + { + "input": "⊏̸", + "description": "Named entity: NotSquareSubset; with a semi-colon", + "output": [ + [ + "Character", + "\u228f\u0338" + ] + ] + }, + { + "input": "&NotSquareSubsetEqual", + "description": "Bad named entity: NotSquareSubsetEqual without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&NotSquareSubsetEqual" + ] + ] + }, + { + "input": "⋢", + "description": "Named entity: NotSquareSubsetEqual; with a semi-colon", + "output": [ + [ + "Character", + "\u22e2" + ] + ] + }, + { + "input": "&NotSquareSuperset", + "description": "Bad named entity: NotSquareSuperset without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&NotSquareSuperset" + ] + ] + }, + { + "input": "⊐̸", + "description": "Named entity: NotSquareSuperset; with a semi-colon", + "output": [ + [ + "Character", + "\u2290\u0338" + ] + ] + }, + { + "input": "&NotSquareSupersetEqual", + "description": "Bad named entity: NotSquareSupersetEqual without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&NotSquareSupersetEqual" + ] + ] + }, + { + "input": "⋣", + "description": "Named entity: NotSquareSupersetEqual; with a semi-colon", + "output": [ + [ + "Character", + "\u22e3" + ] + ] + }, + { + "input": "&NotSubset", + "description": "Bad named entity: NotSubset without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&NotSubset" + ] + ] + }, + { + "input": "⊂⃒", + "description": "Named entity: NotSubset; with a semi-colon", + "output": [ + [ + "Character", + "\u2282\u20d2" + ] + ] + }, + { + "input": "&NotSubsetEqual", + "description": "Bad named entity: NotSubsetEqual without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&NotSubsetEqual" + ] + ] + }, + { + "input": "⊈", + "description": "Named entity: NotSubsetEqual; with a semi-colon", + "output": [ + [ + "Character", + "\u2288" + ] + ] + }, + { + "input": "&NotSucceeds", + "description": "Bad named entity: NotSucceeds without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&NotSucceeds" + ] + ] + }, + { + "input": "⊁", + "description": "Named entity: NotSucceeds; with a semi-colon", + "output": [ + [ + "Character", + "\u2281" + ] + ] + }, + { + "input": "&NotSucceedsEqual", + "description": "Bad named entity: NotSucceedsEqual without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&NotSucceedsEqual" + ] + ] + }, + { + "input": "⪰̸", + "description": "Named entity: NotSucceedsEqual; with a semi-colon", + "output": [ + [ + "Character", + "\u2ab0\u0338" + ] + ] + }, + { + "input": "&NotSucceedsSlantEqual", + "description": "Bad named entity: NotSucceedsSlantEqual without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&NotSucceedsSlantEqual" + ] + ] + }, + { + "input": "⋡", + "description": "Named entity: NotSucceedsSlantEqual; with a semi-colon", + "output": [ + [ + "Character", + "\u22e1" + ] + ] + }, + { + "input": "&NotSucceedsTilde", + "description": "Bad named entity: NotSucceedsTilde without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&NotSucceedsTilde" + ] + ] + }, + { + "input": "≿̸", + "description": "Named entity: NotSucceedsTilde; with a semi-colon", + "output": [ + [ + "Character", + "\u227f\u0338" + ] + ] + }, + { + "input": "&NotSuperset", + "description": "Bad named entity: NotSuperset without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&NotSuperset" + ] + ] + }, + { + "input": "⊃⃒", + "description": "Named entity: NotSuperset; with a semi-colon", + "output": [ + [ + "Character", + "\u2283\u20d2" + ] + ] + }, + { + "input": "&NotSupersetEqual", + "description": "Bad named entity: NotSupersetEqual without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&NotSupersetEqual" + ] + ] + }, + { + "input": "⊉", + "description": "Named entity: NotSupersetEqual; with a semi-colon", + "output": [ + [ + "Character", + "\u2289" + ] + ] + }, + { + "input": "&NotTilde", + "description": "Bad named entity: NotTilde without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&NotTilde" + ] + ] + }, + { + "input": "≁", + "description": "Named entity: NotTilde; with a semi-colon", + "output": [ + [ + "Character", + "\u2241" + ] + ] + }, + { + "input": "&NotTildeEqual", + "description": "Bad named entity: NotTildeEqual without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&NotTildeEqual" + ] + ] + }, + { + "input": "≄", + "description": "Named entity: NotTildeEqual; with a semi-colon", + "output": [ + [ + "Character", + "\u2244" + ] + ] + }, + { + "input": "&NotTildeFullEqual", + "description": "Bad named entity: NotTildeFullEqual without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&NotTildeFullEqual" + ] + ] + }, + { + "input": "≇", + "description": "Named entity: NotTildeFullEqual; with a semi-colon", + "output": [ + [ + "Character", + "\u2247" + ] + ] + }, + { + "input": "&NotTildeTilde", + "description": "Bad named entity: NotTildeTilde without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&NotTildeTilde" + ] + ] + }, + { + "input": "≉", + "description": "Named entity: NotTildeTilde; with a semi-colon", + "output": [ + [ + "Character", + "\u2249" + ] + ] + }, + { + "input": "&NotVerticalBar", + "description": "Bad named entity: NotVerticalBar without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&NotVerticalBar" + ] + ] + }, + { + "input": "∤", + "description": "Named entity: NotVerticalBar; with a semi-colon", + "output": [ + [ + "Character", + "\u2224" + ] + ] + }, + { + "input": "&Nscr", + "description": "Bad named entity: Nscr without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&Nscr" + ] + ] + }, + { + "input": "𝒩", + "description": "Named entity: Nscr; with a semi-colon", + "output": [ + [ + "Character", + "\ud835\udca9" + ] + ] + }, + { + "input": "Ñ", + "description": "Named entity: Ntilde without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "\u00d1" + ] + ] + }, + { + "input": "Ñ", + "description": "Named entity: Ntilde; with a semi-colon", + "output": [ + [ + "Character", + "\u00d1" + ] + ] + }, + { + "input": "&Nu", + "description": "Bad named entity: Nu without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&Nu" + ] + ] + }, + { + "input": "Ν", + "description": "Named entity: Nu; with a semi-colon", + "output": [ + [ + "Character", + "\u039d" + ] + ] + }, + { + "input": "&OElig", + "description": "Bad named entity: OElig without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&OElig" + ] + ] + }, + { + "input": "Œ", + "description": "Named entity: OElig; with a semi-colon", + "output": [ + [ + "Character", + "\u0152" + ] + ] + }, + { + "input": "Ó", + "description": "Named entity: Oacute without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "\u00d3" + ] + ] + }, + { + "input": "Ó", + "description": "Named entity: Oacute; with a semi-colon", + "output": [ + [ + "Character", + "\u00d3" + ] + ] + }, + { + "input": "Ô", + "description": "Named entity: Ocirc without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "\u00d4" + ] + ] + }, + { + "input": "Ô", + "description": "Named entity: Ocirc; with a semi-colon", + "output": [ + [ + "Character", + "\u00d4" + ] + ] + }, + { + "input": "&Ocy", + "description": "Bad named entity: Ocy without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&Ocy" + ] + ] + }, + { + "input": "О", + "description": "Named entity: Ocy; with a semi-colon", + "output": [ + [ + "Character", + "\u041e" + ] + ] + }, + { + "input": "&Odblac", + "description": "Bad named entity: Odblac without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&Odblac" + ] + ] + }, + { + "input": "Ő", + "description": "Named entity: Odblac; with a semi-colon", + "output": [ + [ + "Character", + "\u0150" + ] + ] + }, + { + "input": "&Ofr", + "description": "Bad named entity: Ofr without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&Ofr" + ] + ] + }, + { + "input": "𝔒", + "description": "Named entity: Ofr; with a semi-colon", + "output": [ + [ + "Character", + "\ud835\udd12" + ] + ] + }, + { + "input": "Ò", + "description": "Named entity: Ograve without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "\u00d2" + ] + ] + }, + { + "input": "Ò", + "description": "Named entity: Ograve; with a semi-colon", + "output": [ + [ + "Character", + "\u00d2" + ] + ] + }, + { + "input": "&Omacr", + "description": "Bad named entity: Omacr without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&Omacr" + ] + ] + }, + { + "input": "Ō", + "description": "Named entity: Omacr; with a semi-colon", + "output": [ + [ + "Character", + "\u014c" + ] + ] + }, + { + "input": "&Omega", + "description": "Bad named entity: Omega without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&Omega" + ] + ] + }, + { + "input": "Ω", + "description": "Named entity: Omega; with a semi-colon", + "output": [ + [ + "Character", + "\u03a9" + ] + ] + }, + { + "input": "&Omicron", + "description": "Bad named entity: Omicron without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&Omicron" + ] + ] + }, + { + "input": "Ο", + "description": "Named entity: Omicron; with a semi-colon", + "output": [ + [ + "Character", + "\u039f" + ] + ] + }, + { + "input": "&Oopf", + "description": "Bad named entity: Oopf without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&Oopf" + ] + ] + }, + { + "input": "𝕆", + "description": "Named entity: Oopf; with a semi-colon", + "output": [ + [ + "Character", + "\ud835\udd46" + ] + ] + }, + { + "input": "&OpenCurlyDoubleQuote", + "description": "Bad named entity: OpenCurlyDoubleQuote without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&OpenCurlyDoubleQuote" + ] + ] + }, + { + "input": "“", + "description": "Named entity: OpenCurlyDoubleQuote; with a semi-colon", + "output": [ + [ + "Character", + "\u201c" + ] + ] + }, + { + "input": "&OpenCurlyQuote", + "description": "Bad named entity: OpenCurlyQuote without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&OpenCurlyQuote" + ] + ] + }, + { + "input": "‘", + "description": "Named entity: OpenCurlyQuote; with a semi-colon", + "output": [ + [ + "Character", + "\u2018" + ] + ] + }, + { + "input": "&Or", + "description": "Bad named entity: Or without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&Or" + ] + ] + }, + { + "input": "⩔", + "description": "Named entity: Or; with a semi-colon", + "output": [ + [ + "Character", + "\u2a54" + ] + ] + }, + { + "input": "&Oscr", + "description": "Bad named entity: Oscr without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&Oscr" + ] + ] + }, + { + "input": "𝒪", + "description": "Named entity: Oscr; with a semi-colon", + "output": [ + [ + "Character", + "\ud835\udcaa" + ] + ] + }, + { + "input": "Ø", + "description": "Named entity: Oslash without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "\u00d8" + ] + ] + }, + { + "input": "Ø", + "description": "Named entity: Oslash; with a semi-colon", + "output": [ + [ + "Character", + "\u00d8" + ] + ] + }, + { + "input": "Õ", + "description": "Named entity: Otilde without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "\u00d5" + ] + ] + }, + { + "input": "Õ", + "description": "Named entity: Otilde; with a semi-colon", + "output": [ + [ + "Character", + "\u00d5" + ] + ] + }, + { + "input": "&Otimes", + "description": "Bad named entity: Otimes without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&Otimes" + ] + ] + }, + { + "input": "⨷", + "description": "Named entity: Otimes; with a semi-colon", + "output": [ + [ + "Character", + "\u2a37" + ] + ] + }, + { + "input": "Ö", + "description": "Named entity: Ouml without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "\u00d6" + ] + ] + }, + { + "input": "Ö", + "description": "Named entity: Ouml; with a semi-colon", + "output": [ + [ + "Character", + "\u00d6" + ] + ] + }, + { + "input": "&OverBar", + "description": "Bad named entity: OverBar without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&OverBar" + ] + ] + }, + { + "input": "‾", + "description": "Named entity: OverBar; with a semi-colon", + "output": [ + [ + "Character", + "\u203e" + ] + ] + }, + { + "input": "&OverBrace", + "description": "Bad named entity: OverBrace without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&OverBrace" + ] + ] + }, + { + "input": "⏞", + "description": "Named entity: OverBrace; with a semi-colon", + "output": [ + [ + "Character", + "\u23de" + ] + ] + }, + { + "input": "&OverBracket", + "description": "Bad named entity: OverBracket without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&OverBracket" + ] + ] + }, + { + "input": "⎴", + "description": "Named entity: OverBracket; with a semi-colon", + "output": [ + [ + "Character", + "\u23b4" + ] + ] + }, + { + "input": "&OverParenthesis", + "description": "Bad named entity: OverParenthesis without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&OverParenthesis" + ] + ] + }, + { + "input": "⏜", + "description": "Named entity: OverParenthesis; with a semi-colon", + "output": [ + [ + "Character", + "\u23dc" + ] + ] + }, + { + "input": "&PartialD", + "description": "Bad named entity: PartialD without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&PartialD" + ] + ] + }, + { + "input": "∂", + "description": "Named entity: PartialD; with a semi-colon", + "output": [ + [ + "Character", + "\u2202" + ] + ] + }, + { + "input": "&Pcy", + "description": "Bad named entity: Pcy without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&Pcy" + ] + ] + }, + { + "input": "П", + "description": "Named entity: Pcy; with a semi-colon", + "output": [ + [ + "Character", + "\u041f" + ] + ] + }, + { + "input": "&Pfr", + "description": "Bad named entity: Pfr without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&Pfr" + ] + ] + }, + { + "input": "𝔓", + "description": "Named entity: Pfr; with a semi-colon", + "output": [ + [ + "Character", + "\ud835\udd13" + ] + ] + }, + { + "input": "&Phi", + "description": "Bad named entity: Phi without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&Phi" + ] + ] + }, + { + "input": "Φ", + "description": "Named entity: Phi; with a semi-colon", + "output": [ + [ + "Character", + "\u03a6" + ] + ] + }, + { + "input": "&Pi", + "description": "Bad named entity: Pi without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&Pi" + ] + ] + }, + { + "input": "Π", + "description": "Named entity: Pi; with a semi-colon", + "output": [ + [ + "Character", + "\u03a0" + ] + ] + }, + { + "input": "&PlusMinus", + "description": "Bad named entity: PlusMinus without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&PlusMinus" + ] + ] + }, + { + "input": "±", + "description": "Named entity: PlusMinus; with a semi-colon", + "output": [ + [ + "Character", + "\u00b1" + ] + ] + }, + { + "input": "&Poincareplane", + "description": "Bad named entity: Poincareplane without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&Poincareplane" + ] + ] + }, + { + "input": "ℌ", + "description": "Named entity: Poincareplane; with a semi-colon", + "output": [ + [ + "Character", + "\u210c" + ] + ] + }, + { + "input": "&Popf", + "description": "Bad named entity: Popf without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&Popf" + ] + ] + }, + { + "input": "ℙ", + "description": "Named entity: Popf; with a semi-colon", + "output": [ + [ + "Character", + "\u2119" + ] + ] + }, + { + "input": "&Pr", + "description": "Bad named entity: Pr without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&Pr" + ] + ] + }, + { + "input": "⪻", + "description": "Named entity: Pr; with a semi-colon", + "output": [ + [ + "Character", + "\u2abb" + ] + ] + }, + { + "input": "&Precedes", + "description": "Bad named entity: Precedes without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&Precedes" + ] + ] + }, + { + "input": "≺", + "description": "Named entity: Precedes; with a semi-colon", + "output": [ + [ + "Character", + "\u227a" + ] + ] + }, + { + "input": "&PrecedesEqual", + "description": "Bad named entity: PrecedesEqual without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&PrecedesEqual" + ] + ] + }, + { + "input": "⪯", + "description": "Named entity: PrecedesEqual; with a semi-colon", + "output": [ + [ + "Character", + "\u2aaf" + ] + ] + }, + { + "input": "&PrecedesSlantEqual", + "description": "Bad named entity: PrecedesSlantEqual without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&PrecedesSlantEqual" + ] + ] + }, + { + "input": "≼", + "description": "Named entity: PrecedesSlantEqual; with a semi-colon", + "output": [ + [ + "Character", + "\u227c" + ] + ] + }, + { + "input": "&PrecedesTilde", + "description": "Bad named entity: PrecedesTilde without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&PrecedesTilde" + ] + ] + }, + { + "input": "≾", + "description": "Named entity: PrecedesTilde; with a semi-colon", + "output": [ + [ + "Character", + "\u227e" + ] + ] + }, + { + "input": "&Prime", + "description": "Bad named entity: Prime without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&Prime" + ] + ] + }, + { + "input": "″", + "description": "Named entity: Prime; with a semi-colon", + "output": [ + [ + "Character", + "\u2033" + ] + ] + }, + { + "input": "&Product", + "description": "Bad named entity: Product without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&Product" + ] + ] + }, + { + "input": "∏", + "description": "Named entity: Product; with a semi-colon", + "output": [ + [ + "Character", + "\u220f" + ] + ] + }, + { + "input": "&Proportion", + "description": "Bad named entity: Proportion without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&Proportion" + ] + ] + }, + { + "input": "∷", + "description": "Named entity: Proportion; with a semi-colon", + "output": [ + [ + "Character", + "\u2237" + ] + ] + }, + { + "input": "&Proportional", + "description": "Bad named entity: Proportional without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&Proportional" + ] + ] + }, + { + "input": "∝", + "description": "Named entity: Proportional; with a semi-colon", + "output": [ + [ + "Character", + "\u221d" + ] + ] + }, + { + "input": "&Pscr", + "description": "Bad named entity: Pscr without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&Pscr" + ] + ] + }, + { + "input": "𝒫", + "description": "Named entity: Pscr; with a semi-colon", + "output": [ + [ + "Character", + "\ud835\udcab" + ] + ] + }, + { + "input": "&Psi", + "description": "Bad named entity: Psi without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&Psi" + ] + ] + }, + { + "input": "Ψ", + "description": "Named entity: Psi; with a semi-colon", + "output": [ + [ + "Character", + "\u03a8" + ] + ] + }, + { + "input": """, + "description": "Named entity: QUOT without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "\"" + ] + ] + }, + { + "input": """, + "description": "Named entity: QUOT; with a semi-colon", + "output": [ + [ + "Character", + "\"" + ] + ] + }, + { + "input": "&Qfr", + "description": "Bad named entity: Qfr without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&Qfr" + ] + ] + }, + { + "input": "𝔔", + "description": "Named entity: Qfr; with a semi-colon", + "output": [ + [ + "Character", + "\ud835\udd14" + ] + ] + }, + { + "input": "&Qopf", + "description": "Bad named entity: Qopf without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&Qopf" + ] + ] + }, + { + "input": "ℚ", + "description": "Named entity: Qopf; with a semi-colon", + "output": [ + [ + "Character", + "\u211a" + ] + ] + }, + { + "input": "&Qscr", + "description": "Bad named entity: Qscr without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&Qscr" + ] + ] + }, + { + "input": "𝒬", + "description": "Named entity: Qscr; with a semi-colon", + "output": [ + [ + "Character", + "\ud835\udcac" + ] + ] + }, + { + "input": "&RBarr", + "description": "Bad named entity: RBarr without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&RBarr" + ] + ] + }, + { + "input": "⤐", + "description": "Named entity: RBarr; with a semi-colon", + "output": [ + [ + "Character", + "\u2910" + ] + ] + }, + { + "input": "®", + "description": "Named entity: REG without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "\u00ae" + ] + ] + }, + { + "input": "®", + "description": "Named entity: REG; with a semi-colon", + "output": [ + [ + "Character", + "\u00ae" + ] + ] + }, + { + "input": "&Racute", + "description": "Bad named entity: Racute without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&Racute" + ] + ] + }, + { + "input": "Ŕ", + "description": "Named entity: Racute; with a semi-colon", + "output": [ + [ + "Character", + "\u0154" + ] + ] + }, + { + "input": "&Rang", + "description": "Bad named entity: Rang without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&Rang" + ] + ] + }, + { + "input": "⟫", + "description": "Named entity: Rang; with a semi-colon", + "output": [ + [ + "Character", + "\u27eb" + ] + ] + }, + { + "input": "&Rarr", + "description": "Bad named entity: Rarr without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&Rarr" + ] + ] + }, + { + "input": "↠", + "description": "Named entity: Rarr; with a semi-colon", + "output": [ + [ + "Character", + "\u21a0" + ] + ] + }, + { + "input": "&Rarrtl", + "description": "Bad named entity: Rarrtl without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&Rarrtl" + ] + ] + }, + { + "input": "⤖", + "description": "Named entity: Rarrtl; with a semi-colon", + "output": [ + [ + "Character", + "\u2916" + ] + ] + }, + { + "input": "&Rcaron", + "description": "Bad named entity: Rcaron without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&Rcaron" + ] + ] + }, + { + "input": "Ř", + "description": "Named entity: Rcaron; with a semi-colon", + "output": [ + [ + "Character", + "\u0158" + ] + ] + }, + { + "input": "&Rcedil", + "description": "Bad named entity: Rcedil without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&Rcedil" + ] + ] + }, + { + "input": "Ŗ", + "description": "Named entity: Rcedil; with a semi-colon", + "output": [ + [ + "Character", + "\u0156" + ] + ] + }, + { + "input": "&Rcy", + "description": "Bad named entity: Rcy without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&Rcy" + ] + ] + }, + { + "input": "Р", + "description": "Named entity: Rcy; with a semi-colon", + "output": [ + [ + "Character", + "\u0420" + ] + ] + }, + { + "input": "&Re", + "description": "Bad named entity: Re without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&Re" + ] + ] + }, + { + "input": "ℜ", + "description": "Named entity: Re; with a semi-colon", + "output": [ + [ + "Character", + "\u211c" + ] + ] + }, + { + "input": "&ReverseElement", + "description": "Bad named entity: ReverseElement without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&ReverseElement" + ] + ] + }, + { + "input": "∋", + "description": "Named entity: ReverseElement; with a semi-colon", + "output": [ + [ + "Character", + "\u220b" + ] + ] + }, + { + "input": "&ReverseEquilibrium", + "description": "Bad named entity: ReverseEquilibrium without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&ReverseEquilibrium" + ] + ] + }, + { + "input": "⇋", + "description": "Named entity: ReverseEquilibrium; with a semi-colon", + "output": [ + [ + "Character", + "\u21cb" + ] + ] + }, + { + "input": "&ReverseUpEquilibrium", + "description": "Bad named entity: ReverseUpEquilibrium without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&ReverseUpEquilibrium" + ] + ] + }, + { + "input": "⥯", + "description": "Named entity: ReverseUpEquilibrium; with a semi-colon", + "output": [ + [ + "Character", + "\u296f" + ] + ] + }, + { + "input": "&Rfr", + "description": "Bad named entity: Rfr without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&Rfr" + ] + ] + }, + { + "input": "ℜ", + "description": "Named entity: Rfr; with a semi-colon", + "output": [ + [ + "Character", + "\u211c" + ] + ] + }, + { + "input": "&Rho", + "description": "Bad named entity: Rho without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&Rho" + ] + ] + }, + { + "input": "Ρ", + "description": "Named entity: Rho; with a semi-colon", + "output": [ + [ + "Character", + "\u03a1" + ] + ] + }, + { + "input": "&RightAngleBracket", + "description": "Bad named entity: RightAngleBracket without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&RightAngleBracket" + ] + ] + }, + { + "input": "⟩", + "description": "Named entity: RightAngleBracket; with a semi-colon", + "output": [ + [ + "Character", + "\u27e9" + ] + ] + }, + { + "input": "&RightArrow", + "description": "Bad named entity: RightArrow without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&RightArrow" + ] + ] + }, + { + "input": "→", + "description": "Named entity: RightArrow; with a semi-colon", + "output": [ + [ + "Character", + "\u2192" + ] + ] + }, + { + "input": "&RightArrowBar", + "description": "Bad named entity: RightArrowBar without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&RightArrowBar" + ] + ] + }, + { + "input": "⇥", + "description": "Named entity: RightArrowBar; with a semi-colon", + "output": [ + [ + "Character", + "\u21e5" + ] + ] + }, + { + "input": "&RightArrowLeftArrow", + "description": "Bad named entity: RightArrowLeftArrow without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&RightArrowLeftArrow" + ] + ] + }, + { + "input": "⇄", + "description": "Named entity: RightArrowLeftArrow; with a semi-colon", + "output": [ + [ + "Character", + "\u21c4" + ] + ] + }, + { + "input": "&RightCeiling", + "description": "Bad named entity: RightCeiling without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&RightCeiling" + ] + ] + }, + { + "input": "⌉", + "description": "Named entity: RightCeiling; with a semi-colon", + "output": [ + [ + "Character", + "\u2309" + ] + ] + }, + { + "input": "&RightDoubleBracket", + "description": "Bad named entity: RightDoubleBracket without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&RightDoubleBracket" + ] + ] + }, + { + "input": "⟧", + "description": "Named entity: RightDoubleBracket; with a semi-colon", + "output": [ + [ + "Character", + "\u27e7" + ] + ] + }, + { + "input": "&RightDownTeeVector", + "description": "Bad named entity: RightDownTeeVector without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&RightDownTeeVector" + ] + ] + }, + { + "input": "⥝", + "description": "Named entity: RightDownTeeVector; with a semi-colon", + "output": [ + [ + "Character", + "\u295d" + ] + ] + }, + { + "input": "&RightDownVector", + "description": "Bad named entity: RightDownVector without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&RightDownVector" + ] + ] + }, + { + "input": "⇂", + "description": "Named entity: RightDownVector; with a semi-colon", + "output": [ + [ + "Character", + "\u21c2" + ] + ] + }, + { + "input": "&RightDownVectorBar", + "description": "Bad named entity: RightDownVectorBar without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&RightDownVectorBar" + ] + ] + }, + { + "input": "⥕", + "description": "Named entity: RightDownVectorBar; with a semi-colon", + "output": [ + [ + "Character", + "\u2955" + ] + ] + }, + { + "input": "&RightFloor", + "description": "Bad named entity: RightFloor without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&RightFloor" + ] + ] + }, + { + "input": "⌋", + "description": "Named entity: RightFloor; with a semi-colon", + "output": [ + [ + "Character", + "\u230b" + ] + ] + }, + { + "input": "&RightTee", + "description": "Bad named entity: RightTee without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&RightTee" + ] + ] + }, + { + "input": "⊢", + "description": "Named entity: RightTee; with a semi-colon", + "output": [ + [ + "Character", + "\u22a2" + ] + ] + }, + { + "input": "&RightTeeArrow", + "description": "Bad named entity: RightTeeArrow without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&RightTeeArrow" + ] + ] + }, + { + "input": "↦", + "description": "Named entity: RightTeeArrow; with a semi-colon", + "output": [ + [ + "Character", + "\u21a6" + ] + ] + }, + { + "input": "&RightTeeVector", + "description": "Bad named entity: RightTeeVector without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&RightTeeVector" + ] + ] + }, + { + "input": "⥛", + "description": "Named entity: RightTeeVector; with a semi-colon", + "output": [ + [ + "Character", + "\u295b" + ] + ] + }, + { + "input": "&RightTriangle", + "description": "Bad named entity: RightTriangle without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&RightTriangle" + ] + ] + }, + { + "input": "⊳", + "description": "Named entity: RightTriangle; with a semi-colon", + "output": [ + [ + "Character", + "\u22b3" + ] + ] + }, + { + "input": "&RightTriangleBar", + "description": "Bad named entity: RightTriangleBar without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&RightTriangleBar" + ] + ] + }, + { + "input": "⧐", + "description": "Named entity: RightTriangleBar; with a semi-colon", + "output": [ + [ + "Character", + "\u29d0" + ] + ] + }, + { + "input": "&RightTriangleEqual", + "description": "Bad named entity: RightTriangleEqual without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&RightTriangleEqual" + ] + ] + }, + { + "input": "⊵", + "description": "Named entity: RightTriangleEqual; with a semi-colon", + "output": [ + [ + "Character", + "\u22b5" + ] + ] + }, + { + "input": "&RightUpDownVector", + "description": "Bad named entity: RightUpDownVector without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&RightUpDownVector" + ] + ] + }, + { + "input": "⥏", + "description": "Named entity: RightUpDownVector; with a semi-colon", + "output": [ + [ + "Character", + "\u294f" + ] + ] + }, + { + "input": "&RightUpTeeVector", + "description": "Bad named entity: RightUpTeeVector without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&RightUpTeeVector" + ] + ] + }, + { + "input": "⥜", + "description": "Named entity: RightUpTeeVector; with a semi-colon", + "output": [ + [ + "Character", + "\u295c" + ] + ] + }, + { + "input": "&RightUpVector", + "description": "Bad named entity: RightUpVector without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&RightUpVector" + ] + ] + }, + { + "input": "↾", + "description": "Named entity: RightUpVector; with a semi-colon", + "output": [ + [ + "Character", + "\u21be" + ] + ] + }, + { + "input": "&RightUpVectorBar", + "description": "Bad named entity: RightUpVectorBar without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&RightUpVectorBar" + ] + ] + }, + { + "input": "⥔", + "description": "Named entity: RightUpVectorBar; with a semi-colon", + "output": [ + [ + "Character", + "\u2954" + ] + ] + }, + { + "input": "&RightVector", + "description": "Bad named entity: RightVector without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&RightVector" + ] + ] + }, + { + "input": "⇀", + "description": "Named entity: RightVector; with a semi-colon", + "output": [ + [ + "Character", + "\u21c0" + ] + ] + }, + { + "input": "&RightVectorBar", + "description": "Bad named entity: RightVectorBar without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&RightVectorBar" + ] + ] + }, + { + "input": "⥓", + "description": "Named entity: RightVectorBar; with a semi-colon", + "output": [ + [ + "Character", + "\u2953" + ] + ] + }, + { + "input": "&Rightarrow", + "description": "Bad named entity: Rightarrow without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&Rightarrow" + ] + ] + }, + { + "input": "⇒", + "description": "Named entity: Rightarrow; with a semi-colon", + "output": [ + [ + "Character", + "\u21d2" + ] + ] + }, + { + "input": "&Ropf", + "description": "Bad named entity: Ropf without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&Ropf" + ] + ] + }, + { + "input": "ℝ", + "description": "Named entity: Ropf; with a semi-colon", + "output": [ + [ + "Character", + "\u211d" + ] + ] + }, + { + "input": "&RoundImplies", + "description": "Bad named entity: RoundImplies without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&RoundImplies" + ] + ] + }, + { + "input": "⥰", + "description": "Named entity: RoundImplies; with a semi-colon", + "output": [ + [ + "Character", + "\u2970" + ] + ] + }, + { + "input": "&Rrightarrow", + "description": "Bad named entity: Rrightarrow without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&Rrightarrow" + ] + ] + }, + { + "input": "⇛", + "description": "Named entity: Rrightarrow; with a semi-colon", + "output": [ + [ + "Character", + "\u21db" + ] + ] + }, + { + "input": "&Rscr", + "description": "Bad named entity: Rscr without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&Rscr" + ] + ] + }, + { + "input": "ℛ", + "description": "Named entity: Rscr; with a semi-colon", + "output": [ + [ + "Character", + "\u211b" + ] + ] + }, + { + "input": "&Rsh", + "description": "Bad named entity: Rsh without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&Rsh" + ] + ] + }, + { + "input": "↱", + "description": "Named entity: Rsh; with a semi-colon", + "output": [ + [ + "Character", + "\u21b1" + ] + ] + }, + { + "input": "&RuleDelayed", + "description": "Bad named entity: RuleDelayed without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&RuleDelayed" + ] + ] + }, + { + "input": "⧴", + "description": "Named entity: RuleDelayed; with a semi-colon", + "output": [ + [ + "Character", + "\u29f4" + ] + ] + }, + { + "input": "&SHCHcy", + "description": "Bad named entity: SHCHcy without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&SHCHcy" + ] + ] + }, + { + "input": "Щ", + "description": "Named entity: SHCHcy; with a semi-colon", + "output": [ + [ + "Character", + "\u0429" + ] + ] + }, + { + "input": "&SHcy", + "description": "Bad named entity: SHcy without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&SHcy" + ] + ] + }, + { + "input": "Ш", + "description": "Named entity: SHcy; with a semi-colon", + "output": [ + [ + "Character", + "\u0428" + ] + ] + }, + { + "input": "&SOFTcy", + "description": "Bad named entity: SOFTcy without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&SOFTcy" + ] + ] + }, + { + "input": "Ь", + "description": "Named entity: SOFTcy; with a semi-colon", + "output": [ + [ + "Character", + "\u042c" + ] + ] + }, + { + "input": "&Sacute", + "description": "Bad named entity: Sacute without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&Sacute" + ] + ] + }, + { + "input": "Ś", + "description": "Named entity: Sacute; with a semi-colon", + "output": [ + [ + "Character", + "\u015a" + ] + ] + }, + { + "input": "&Sc", + "description": "Bad named entity: Sc without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&Sc" + ] + ] + }, + { + "input": "⪼", + "description": "Named entity: Sc; with a semi-colon", + "output": [ + [ + "Character", + "\u2abc" + ] + ] + }, + { + "input": "&Scaron", + "description": "Bad named entity: Scaron without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&Scaron" + ] + ] + }, + { + "input": "Š", + "description": "Named entity: Scaron; with a semi-colon", + "output": [ + [ + "Character", + "\u0160" + ] + ] + }, + { + "input": "&Scedil", + "description": "Bad named entity: Scedil without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&Scedil" + ] + ] + }, + { + "input": "Ş", + "description": "Named entity: Scedil; with a semi-colon", + "output": [ + [ + "Character", + "\u015e" + ] + ] + }, + { + "input": "&Scirc", + "description": "Bad named entity: Scirc without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&Scirc" + ] + ] + }, + { + "input": "Ŝ", + "description": "Named entity: Scirc; with a semi-colon", + "output": [ + [ + "Character", + "\u015c" + ] + ] + }, + { + "input": "&Scy", + "description": "Bad named entity: Scy without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&Scy" + ] + ] + }, + { + "input": "С", + "description": "Named entity: Scy; with a semi-colon", + "output": [ + [ + "Character", + "\u0421" + ] + ] + }, + { + "input": "&Sfr", + "description": "Bad named entity: Sfr without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&Sfr" + ] + ] + }, + { + "input": "𝔖", + "description": "Named entity: Sfr; with a semi-colon", + "output": [ + [ + "Character", + "\ud835\udd16" + ] + ] + }, + { + "input": "&ShortDownArrow", + "description": "Bad named entity: ShortDownArrow without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&ShortDownArrow" + ] + ] + }, + { + "input": "↓", + "description": "Named entity: ShortDownArrow; with a semi-colon", + "output": [ + [ + "Character", + "\u2193" + ] + ] + }, + { + "input": "&ShortLeftArrow", + "description": "Bad named entity: ShortLeftArrow without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&ShortLeftArrow" + ] + ] + }, + { + "input": "←", + "description": "Named entity: ShortLeftArrow; with a semi-colon", + "output": [ + [ + "Character", + "\u2190" + ] + ] + }, + { + "input": "&ShortRightArrow", + "description": "Bad named entity: ShortRightArrow without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&ShortRightArrow" + ] + ] + }, + { + "input": "→", + "description": "Named entity: ShortRightArrow; with a semi-colon", + "output": [ + [ + "Character", + "\u2192" + ] + ] + }, + { + "input": "&ShortUpArrow", + "description": "Bad named entity: ShortUpArrow without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&ShortUpArrow" + ] + ] + }, + { + "input": "↑", + "description": "Named entity: ShortUpArrow; with a semi-colon", + "output": [ + [ + "Character", + "\u2191" + ] + ] + }, + { + "input": "&Sigma", + "description": "Bad named entity: Sigma without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&Sigma" + ] + ] + }, + { + "input": "Σ", + "description": "Named entity: Sigma; with a semi-colon", + "output": [ + [ + "Character", + "\u03a3" + ] + ] + }, + { + "input": "&SmallCircle", + "description": "Bad named entity: SmallCircle without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&SmallCircle" + ] + ] + }, + { + "input": "∘", + "description": "Named entity: SmallCircle; with a semi-colon", + "output": [ + [ + "Character", + "\u2218" + ] + ] + }, + { + "input": "&Sopf", + "description": "Bad named entity: Sopf without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&Sopf" + ] + ] + }, + { + "input": "𝕊", + "description": "Named entity: Sopf; with a semi-colon", + "output": [ + [ + "Character", + "\ud835\udd4a" + ] + ] + }, + { + "input": "&Sqrt", + "description": "Bad named entity: Sqrt without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&Sqrt" + ] + ] + }, + { + "input": "√", + "description": "Named entity: Sqrt; with a semi-colon", + "output": [ + [ + "Character", + "\u221a" + ] + ] + }, + { + "input": "&Square", + "description": "Bad named entity: Square without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&Square" + ] + ] + }, + { + "input": "□", + "description": "Named entity: Square; with a semi-colon", + "output": [ + [ + "Character", + "\u25a1" + ] + ] + }, + { + "input": "&SquareIntersection", + "description": "Bad named entity: SquareIntersection without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&SquareIntersection" + ] + ] + }, + { + "input": "⊓", + "description": "Named entity: SquareIntersection; with a semi-colon", + "output": [ + [ + "Character", + "\u2293" + ] + ] + }, + { + "input": "&SquareSubset", + "description": "Bad named entity: SquareSubset without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&SquareSubset" + ] + ] + }, + { + "input": "⊏", + "description": "Named entity: SquareSubset; with a semi-colon", + "output": [ + [ + "Character", + "\u228f" + ] + ] + }, + { + "input": "&SquareSubsetEqual", + "description": "Bad named entity: SquareSubsetEqual without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&SquareSubsetEqual" + ] + ] + }, + { + "input": "⊑", + "description": "Named entity: SquareSubsetEqual; with a semi-colon", + "output": [ + [ + "Character", + "\u2291" + ] + ] + }, + { + "input": "&SquareSuperset", + "description": "Bad named entity: SquareSuperset without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&SquareSuperset" + ] + ] + }, + { + "input": "⊐", + "description": "Named entity: SquareSuperset; with a semi-colon", + "output": [ + [ + "Character", + "\u2290" + ] + ] + }, + { + "input": "&SquareSupersetEqual", + "description": "Bad named entity: SquareSupersetEqual without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&SquareSupersetEqual" + ] + ] + }, + { + "input": "⊒", + "description": "Named entity: SquareSupersetEqual; with a semi-colon", + "output": [ + [ + "Character", + "\u2292" + ] + ] + }, + { + "input": "&SquareUnion", + "description": "Bad named entity: SquareUnion without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&SquareUnion" + ] + ] + }, + { + "input": "⊔", + "description": "Named entity: SquareUnion; with a semi-colon", + "output": [ + [ + "Character", + "\u2294" + ] + ] + }, + { + "input": "&Sscr", + "description": "Bad named entity: Sscr without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&Sscr" + ] + ] + }, + { + "input": "𝒮", + "description": "Named entity: Sscr; with a semi-colon", + "output": [ + [ + "Character", + "\ud835\udcae" + ] + ] + }, + { + "input": "&Star", + "description": "Bad named entity: Star without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&Star" + ] + ] + }, + { + "input": "⋆", + "description": "Named entity: Star; with a semi-colon", + "output": [ + [ + "Character", + "\u22c6" + ] + ] + }, + { + "input": "&Sub", + "description": "Bad named entity: Sub without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&Sub" + ] + ] + }, + { + "input": "⋐", + "description": "Named entity: Sub; with a semi-colon", + "output": [ + [ + "Character", + "\u22d0" + ] + ] + }, + { + "input": "&Subset", + "description": "Bad named entity: Subset without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&Subset" + ] + ] + }, + { + "input": "⋐", + "description": "Named entity: Subset; with a semi-colon", + "output": [ + [ + "Character", + "\u22d0" + ] + ] + }, + { + "input": "&SubsetEqual", + "description": "Bad named entity: SubsetEqual without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&SubsetEqual" + ] + ] + }, + { + "input": "⊆", + "description": "Named entity: SubsetEqual; with a semi-colon", + "output": [ + [ + "Character", + "\u2286" + ] + ] + }, + { + "input": "&Succeeds", + "description": "Bad named entity: Succeeds without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&Succeeds" + ] + ] + }, + { + "input": "≻", + "description": "Named entity: Succeeds; with a semi-colon", + "output": [ + [ + "Character", + "\u227b" + ] + ] + }, + { + "input": "&SucceedsEqual", + "description": "Bad named entity: SucceedsEqual without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&SucceedsEqual" + ] + ] + }, + { + "input": "⪰", + "description": "Named entity: SucceedsEqual; with a semi-colon", + "output": [ + [ + "Character", + "\u2ab0" + ] + ] + }, + { + "input": "&SucceedsSlantEqual", + "description": "Bad named entity: SucceedsSlantEqual without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&SucceedsSlantEqual" + ] + ] + }, + { + "input": "≽", + "description": "Named entity: SucceedsSlantEqual; with a semi-colon", + "output": [ + [ + "Character", + "\u227d" + ] + ] + }, + { + "input": "&SucceedsTilde", + "description": "Bad named entity: SucceedsTilde without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&SucceedsTilde" + ] + ] + }, + { + "input": "≿", + "description": "Named entity: SucceedsTilde; with a semi-colon", + "output": [ + [ + "Character", + "\u227f" + ] + ] + }, + { + "input": "&SuchThat", + "description": "Bad named entity: SuchThat without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&SuchThat" + ] + ] + }, + { + "input": "∋", + "description": "Named entity: SuchThat; with a semi-colon", + "output": [ + [ + "Character", + "\u220b" + ] + ] + }, + { + "input": "&Sum", + "description": "Bad named entity: Sum without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&Sum" + ] + ] + }, + { + "input": "∑", + "description": "Named entity: Sum; with a semi-colon", + "output": [ + [ + "Character", + "\u2211" + ] + ] + }, + { + "input": "&Sup", + "description": "Bad named entity: Sup without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&Sup" + ] + ] + }, + { + "input": "⋑", + "description": "Named entity: Sup; with a semi-colon", + "output": [ + [ + "Character", + "\u22d1" + ] + ] + }, + { + "input": "&Superset", + "description": "Bad named entity: Superset without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&Superset" + ] + ] + }, + { + "input": "⊃", + "description": "Named entity: Superset; with a semi-colon", + "output": [ + [ + "Character", + "\u2283" + ] + ] + }, + { + "input": "&SupersetEqual", + "description": "Bad named entity: SupersetEqual without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&SupersetEqual" + ] + ] + }, + { + "input": "⊇", + "description": "Named entity: SupersetEqual; with a semi-colon", + "output": [ + [ + "Character", + "\u2287" + ] + ] + }, + { + "input": "&Supset", + "description": "Bad named entity: Supset without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&Supset" + ] + ] + }, + { + "input": "⋑", + "description": "Named entity: Supset; with a semi-colon", + "output": [ + [ + "Character", + "\u22d1" + ] + ] + }, + { + "input": "Þ", + "description": "Named entity: THORN without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "\u00de" + ] + ] + }, + { + "input": "Þ", + "description": "Named entity: THORN; with a semi-colon", + "output": [ + [ + "Character", + "\u00de" + ] + ] + }, + { + "input": "&TRADE", + "description": "Bad named entity: TRADE without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&TRADE" + ] + ] + }, + { + "input": "™", + "description": "Named entity: TRADE; with a semi-colon", + "output": [ + [ + "Character", + "\u2122" + ] + ] + }, + { + "input": "&TSHcy", + "description": "Bad named entity: TSHcy without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&TSHcy" + ] + ] + }, + { + "input": "Ћ", + "description": "Named entity: TSHcy; with a semi-colon", + "output": [ + [ + "Character", + "\u040b" + ] + ] + }, + { + "input": "&TScy", + "description": "Bad named entity: TScy without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&TScy" + ] + ] + }, + { + "input": "Ц", + "description": "Named entity: TScy; with a semi-colon", + "output": [ + [ + "Character", + "\u0426" + ] + ] + }, + { + "input": "&Tab", + "description": "Bad named entity: Tab without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&Tab" + ] + ] + }, + { + "input": " ", + "description": "Named entity: Tab; with a semi-colon", + "output": [ + [ + "Character", + "\t" + ] + ] + }, + { + "input": "&Tau", + "description": "Bad named entity: Tau without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&Tau" + ] + ] + }, + { + "input": "Τ", + "description": "Named entity: Tau; with a semi-colon", + "output": [ + [ + "Character", + "\u03a4" + ] + ] + }, + { + "input": "&Tcaron", + "description": "Bad named entity: Tcaron without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&Tcaron" + ] + ] + }, + { + "input": "Ť", + "description": "Named entity: Tcaron; with a semi-colon", + "output": [ + [ + "Character", + "\u0164" + ] + ] + }, + { + "input": "&Tcedil", + "description": "Bad named entity: Tcedil without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&Tcedil" + ] + ] + }, + { + "input": "Ţ", + "description": "Named entity: Tcedil; with a semi-colon", + "output": [ + [ + "Character", + "\u0162" + ] + ] + }, + { + "input": "&Tcy", + "description": "Bad named entity: Tcy without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&Tcy" + ] + ] + }, + { + "input": "Т", + "description": "Named entity: Tcy; with a semi-colon", + "output": [ + [ + "Character", + "\u0422" + ] + ] + }, + { + "input": "&Tfr", + "description": "Bad named entity: Tfr without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&Tfr" + ] + ] + }, + { + "input": "𝔗", + "description": "Named entity: Tfr; with a semi-colon", + "output": [ + [ + "Character", + "\ud835\udd17" + ] + ] + }, + { + "input": "&Therefore", + "description": "Bad named entity: Therefore without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&Therefore" + ] + ] + }, + { + "input": "∴", + "description": "Named entity: Therefore; with a semi-colon", + "output": [ + [ + "Character", + "\u2234" + ] + ] + }, + { + "input": "&Theta", + "description": "Bad named entity: Theta without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&Theta" + ] + ] + }, + { + "input": "Θ", + "description": "Named entity: Theta; with a semi-colon", + "output": [ + [ + "Character", + "\u0398" + ] + ] + }, + { + "input": "&ThickSpace", + "description": "Bad named entity: ThickSpace without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&ThickSpace" + ] + ] + }, + { + "input": "  ", + "description": "Named entity: ThickSpace; with a semi-colon", + "output": [ + [ + "Character", + "\u205f\u200a" + ] + ] + }, + { + "input": "&ThinSpace", + "description": "Bad named entity: ThinSpace without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&ThinSpace" + ] + ] + }, + { + "input": " ", + "description": "Named entity: ThinSpace; with a semi-colon", + "output": [ + [ + "Character", + "\u2009" + ] + ] + }, + { + "input": "&Tilde", + "description": "Bad named entity: Tilde without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&Tilde" + ] + ] + }, + { + "input": "∼", + "description": "Named entity: Tilde; with a semi-colon", + "output": [ + [ + "Character", + "\u223c" + ] + ] + }, + { + "input": "&TildeEqual", + "description": "Bad named entity: TildeEqual without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&TildeEqual" + ] + ] + }, + { + "input": "≃", + "description": "Named entity: TildeEqual; with a semi-colon", + "output": [ + [ + "Character", + "\u2243" + ] + ] + }, + { + "input": "&TildeFullEqual", + "description": "Bad named entity: TildeFullEqual without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&TildeFullEqual" + ] + ] + }, + { + "input": "≅", + "description": "Named entity: TildeFullEqual; with a semi-colon", + "output": [ + [ + "Character", + "\u2245" + ] + ] + }, + { + "input": "&TildeTilde", + "description": "Bad named entity: TildeTilde without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&TildeTilde" + ] + ] + }, + { + "input": "≈", + "description": "Named entity: TildeTilde; with a semi-colon", + "output": [ + [ + "Character", + "\u2248" + ] + ] + }, + { + "input": "&Topf", + "description": "Bad named entity: Topf without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&Topf" + ] + ] + }, + { + "input": "𝕋", + "description": "Named entity: Topf; with a semi-colon", + "output": [ + [ + "Character", + "\ud835\udd4b" + ] + ] + }, + { + "input": "&TripleDot", + "description": "Bad named entity: TripleDot without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&TripleDot" + ] + ] + }, + { + "input": "⃛", + "description": "Named entity: TripleDot; with a semi-colon", + "output": [ + [ + "Character", + "\u20db" + ] + ] + }, + { + "input": "&Tscr", + "description": "Bad named entity: Tscr without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&Tscr" + ] + ] + }, + { + "input": "𝒯", + "description": "Named entity: Tscr; with a semi-colon", + "output": [ + [ + "Character", + "\ud835\udcaf" + ] + ] + }, + { + "input": "&Tstrok", + "description": "Bad named entity: Tstrok without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&Tstrok" + ] + ] + }, + { + "input": "Ŧ", + "description": "Named entity: Tstrok; with a semi-colon", + "output": [ + [ + "Character", + "\u0166" + ] + ] + }, + { + "input": "Ú", + "description": "Named entity: Uacute without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "\u00da" + ] + ] + }, + { + "input": "Ú", + "description": "Named entity: Uacute; with a semi-colon", + "output": [ + [ + "Character", + "\u00da" + ] + ] + }, + { + "input": "&Uarr", + "description": "Bad named entity: Uarr without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&Uarr" + ] + ] + }, + { + "input": "↟", + "description": "Named entity: Uarr; with a semi-colon", + "output": [ + [ + "Character", + "\u219f" + ] + ] + }, + { + "input": "&Uarrocir", + "description": "Bad named entity: Uarrocir without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&Uarrocir" + ] + ] + }, + { + "input": "⥉", + "description": "Named entity: Uarrocir; with a semi-colon", + "output": [ + [ + "Character", + "\u2949" + ] + ] + }, + { + "input": "&Ubrcy", + "description": "Bad named entity: Ubrcy without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&Ubrcy" + ] + ] + }, + { + "input": "Ў", + "description": "Named entity: Ubrcy; with a semi-colon", + "output": [ + [ + "Character", + "\u040e" + ] + ] + }, + { + "input": "&Ubreve", + "description": "Bad named entity: Ubreve without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&Ubreve" + ] + ] + }, + { + "input": "Ŭ", + "description": "Named entity: Ubreve; with a semi-colon", + "output": [ + [ + "Character", + "\u016c" + ] + ] + }, + { + "input": "Û", + "description": "Named entity: Ucirc without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "\u00db" + ] + ] + }, + { + "input": "Û", + "description": "Named entity: Ucirc; with a semi-colon", + "output": [ + [ + "Character", + "\u00db" + ] + ] + }, + { + "input": "&Ucy", + "description": "Bad named entity: Ucy without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&Ucy" + ] + ] + }, + { + "input": "У", + "description": "Named entity: Ucy; with a semi-colon", + "output": [ + [ + "Character", + "\u0423" + ] + ] + }, + { + "input": "&Udblac", + "description": "Bad named entity: Udblac without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&Udblac" + ] + ] + }, + { + "input": "Ű", + "description": "Named entity: Udblac; with a semi-colon", + "output": [ + [ + "Character", + "\u0170" + ] + ] + }, + { + "input": "&Ufr", + "description": "Bad named entity: Ufr without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&Ufr" + ] + ] + }, + { + "input": "𝔘", + "description": "Named entity: Ufr; with a semi-colon", + "output": [ + [ + "Character", + "\ud835\udd18" + ] + ] + }, + { + "input": "Ù", + "description": "Named entity: Ugrave without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "\u00d9" + ] + ] + }, + { + "input": "Ù", + "description": "Named entity: Ugrave; with a semi-colon", + "output": [ + [ + "Character", + "\u00d9" + ] + ] + }, + { + "input": "&Umacr", + "description": "Bad named entity: Umacr without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&Umacr" + ] + ] + }, + { + "input": "Ū", + "description": "Named entity: Umacr; with a semi-colon", + "output": [ + [ + "Character", + "\u016a" + ] + ] + }, + { + "input": "&UnderBar", + "description": "Bad named entity: UnderBar without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&UnderBar" + ] + ] + }, + { + "input": "_", + "description": "Named entity: UnderBar; with a semi-colon", + "output": [ + [ + "Character", + "_" + ] + ] + }, + { + "input": "&UnderBrace", + "description": "Bad named entity: UnderBrace without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&UnderBrace" + ] + ] + }, + { + "input": "⏟", + "description": "Named entity: UnderBrace; with a semi-colon", + "output": [ + [ + "Character", + "\u23df" + ] + ] + }, + { + "input": "&UnderBracket", + "description": "Bad named entity: UnderBracket without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&UnderBracket" + ] + ] + }, + { + "input": "⎵", + "description": "Named entity: UnderBracket; with a semi-colon", + "output": [ + [ + "Character", + "\u23b5" + ] + ] + }, + { + "input": "&UnderParenthesis", + "description": "Bad named entity: UnderParenthesis without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&UnderParenthesis" + ] + ] + }, + { + "input": "⏝", + "description": "Named entity: UnderParenthesis; with a semi-colon", + "output": [ + [ + "Character", + "\u23dd" + ] + ] + }, + { + "input": "&Union", + "description": "Bad named entity: Union without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&Union" + ] + ] + }, + { + "input": "⋃", + "description": "Named entity: Union; with a semi-colon", + "output": [ + [ + "Character", + "\u22c3" + ] + ] + }, + { + "input": "&UnionPlus", + "description": "Bad named entity: UnionPlus without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&UnionPlus" + ] + ] + }, + { + "input": "⊎", + "description": "Named entity: UnionPlus; with a semi-colon", + "output": [ + [ + "Character", + "\u228e" + ] + ] + }, + { + "input": "&Uogon", + "description": "Bad named entity: Uogon without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&Uogon" + ] + ] + }, + { + "input": "Ų", + "description": "Named entity: Uogon; with a semi-colon", + "output": [ + [ + "Character", + "\u0172" + ] + ] + }, + { + "input": "&Uopf", + "description": "Bad named entity: Uopf without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&Uopf" + ] + ] + }, + { + "input": "𝕌", + "description": "Named entity: Uopf; with a semi-colon", + "output": [ + [ + "Character", + "\ud835\udd4c" + ] + ] + }, + { + "input": "&UpArrow", + "description": "Bad named entity: UpArrow without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&UpArrow" + ] + ] + }, + { + "input": "↑", + "description": "Named entity: UpArrow; with a semi-colon", + "output": [ + [ + "Character", + "\u2191" + ] + ] + }, + { + "input": "&UpArrowBar", + "description": "Bad named entity: UpArrowBar without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&UpArrowBar" + ] + ] + }, + { + "input": "⤒", + "description": "Named entity: UpArrowBar; with a semi-colon", + "output": [ + [ + "Character", + "\u2912" + ] + ] + }, + { + "input": "&UpArrowDownArrow", + "description": "Bad named entity: UpArrowDownArrow without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&UpArrowDownArrow" + ] + ] + }, + { + "input": "⇅", + "description": "Named entity: UpArrowDownArrow; with a semi-colon", + "output": [ + [ + "Character", + "\u21c5" + ] + ] + }, + { + "input": "&UpDownArrow", + "description": "Bad named entity: UpDownArrow without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&UpDownArrow" + ] + ] + }, + { + "input": "↕", + "description": "Named entity: UpDownArrow; with a semi-colon", + "output": [ + [ + "Character", + "\u2195" + ] + ] + }, + { + "input": "&UpEquilibrium", + "description": "Bad named entity: UpEquilibrium without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&UpEquilibrium" + ] + ] + }, + { + "input": "⥮", + "description": "Named entity: UpEquilibrium; with a semi-colon", + "output": [ + [ + "Character", + "\u296e" + ] + ] + }, + { + "input": "&UpTee", + "description": "Bad named entity: UpTee without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&UpTee" + ] + ] + }, + { + "input": "⊥", + "description": "Named entity: UpTee; with a semi-colon", + "output": [ + [ + "Character", + "\u22a5" + ] + ] + }, + { + "input": "&UpTeeArrow", + "description": "Bad named entity: UpTeeArrow without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&UpTeeArrow" + ] + ] + }, + { + "input": "↥", + "description": "Named entity: UpTeeArrow; with a semi-colon", + "output": [ + [ + "Character", + "\u21a5" + ] + ] + }, + { + "input": "&Uparrow", + "description": "Bad named entity: Uparrow without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&Uparrow" + ] + ] + }, + { + "input": "⇑", + "description": "Named entity: Uparrow; with a semi-colon", + "output": [ + [ + "Character", + "\u21d1" + ] + ] + }, + { + "input": "&Updownarrow", + "description": "Bad named entity: Updownarrow without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&Updownarrow" + ] + ] + }, + { + "input": "⇕", + "description": "Named entity: Updownarrow; with a semi-colon", + "output": [ + [ + "Character", + "\u21d5" + ] + ] + }, + { + "input": "&UpperLeftArrow", + "description": "Bad named entity: UpperLeftArrow without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&UpperLeftArrow" + ] + ] + }, + { + "input": "↖", + "description": "Named entity: UpperLeftArrow; with a semi-colon", + "output": [ + [ + "Character", + "\u2196" + ] + ] + }, + { + "input": "&UpperRightArrow", + "description": "Bad named entity: UpperRightArrow without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&UpperRightArrow" + ] + ] + }, + { + "input": "↗", + "description": "Named entity: UpperRightArrow; with a semi-colon", + "output": [ + [ + "Character", + "\u2197" + ] + ] + }, + { + "input": "&Upsi", + "description": "Bad named entity: Upsi without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&Upsi" + ] + ] + }, + { + "input": "ϒ", + "description": "Named entity: Upsi; with a semi-colon", + "output": [ + [ + "Character", + "\u03d2" + ] + ] + }, + { + "input": "&Upsilon", + "description": "Bad named entity: Upsilon without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&Upsilon" + ] + ] + }, + { + "input": "Υ", + "description": "Named entity: Upsilon; with a semi-colon", + "output": [ + [ + "Character", + "\u03a5" + ] + ] + }, + { + "input": "&Uring", + "description": "Bad named entity: Uring without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&Uring" + ] + ] + }, + { + "input": "Ů", + "description": "Named entity: Uring; with a semi-colon", + "output": [ + [ + "Character", + "\u016e" + ] + ] + }, + { + "input": "&Uscr", + "description": "Bad named entity: Uscr without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&Uscr" + ] + ] + }, + { + "input": "𝒰", + "description": "Named entity: Uscr; with a semi-colon", + "output": [ + [ + "Character", + "\ud835\udcb0" + ] + ] + }, + { + "input": "&Utilde", + "description": "Bad named entity: Utilde without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&Utilde" + ] + ] + }, + { + "input": "Ũ", + "description": "Named entity: Utilde; with a semi-colon", + "output": [ + [ + "Character", + "\u0168" + ] + ] + }, + { + "input": "Ü", + "description": "Named entity: Uuml without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "\u00dc" + ] + ] + }, + { + "input": "Ü", + "description": "Named entity: Uuml; with a semi-colon", + "output": [ + [ + "Character", + "\u00dc" + ] + ] + }, + { + "input": "&VDash", + "description": "Bad named entity: VDash without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&VDash" + ] + ] + }, + { + "input": "⊫", + "description": "Named entity: VDash; with a semi-colon", + "output": [ + [ + "Character", + "\u22ab" + ] + ] + }, + { + "input": "&Vbar", + "description": "Bad named entity: Vbar without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&Vbar" + ] + ] + }, + { + "input": "⫫", + "description": "Named entity: Vbar; with a semi-colon", + "output": [ + [ + "Character", + "\u2aeb" + ] + ] + }, + { + "input": "&Vcy", + "description": "Bad named entity: Vcy without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&Vcy" + ] + ] + }, + { + "input": "В", + "description": "Named entity: Vcy; with a semi-colon", + "output": [ + [ + "Character", + "\u0412" + ] + ] + }, + { + "input": "&Vdash", + "description": "Bad named entity: Vdash without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&Vdash" + ] + ] + }, + { + "input": "⊩", + "description": "Named entity: Vdash; with a semi-colon", + "output": [ + [ + "Character", + "\u22a9" + ] + ] + }, + { + "input": "&Vdashl", + "description": "Bad named entity: Vdashl without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&Vdashl" + ] + ] + }, + { + "input": "⫦", + "description": "Named entity: Vdashl; with a semi-colon", + "output": [ + [ + "Character", + "\u2ae6" + ] + ] + }, + { + "input": "&Vee", + "description": "Bad named entity: Vee without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&Vee" + ] + ] + }, + { + "input": "⋁", + "description": "Named entity: Vee; with a semi-colon", + "output": [ + [ + "Character", + "\u22c1" + ] + ] + }, + { + "input": "&Verbar", + "description": "Bad named entity: Verbar without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&Verbar" + ] + ] + }, + { + "input": "‖", + "description": "Named entity: Verbar; with a semi-colon", + "output": [ + [ + "Character", + "\u2016" + ] + ] + }, + { + "input": "&Vert", + "description": "Bad named entity: Vert without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&Vert" + ] + ] + }, + { + "input": "‖", + "description": "Named entity: Vert; with a semi-colon", + "output": [ + [ + "Character", + "\u2016" + ] + ] + }, + { + "input": "&VerticalBar", + "description": "Bad named entity: VerticalBar without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&VerticalBar" + ] + ] + }, + { + "input": "∣", + "description": "Named entity: VerticalBar; with a semi-colon", + "output": [ + [ + "Character", + "\u2223" + ] + ] + }, + { + "input": "&VerticalLine", + "description": "Bad named entity: VerticalLine without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&VerticalLine" + ] + ] + }, + { + "input": "|", + "description": "Named entity: VerticalLine; with a semi-colon", + "output": [ + [ + "Character", + "|" + ] + ] + }, + { + "input": "&VerticalSeparator", + "description": "Bad named entity: VerticalSeparator without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&VerticalSeparator" + ] + ] + }, + { + "input": "❘", + "description": "Named entity: VerticalSeparator; with a semi-colon", + "output": [ + [ + "Character", + "\u2758" + ] + ] + }, + { + "input": "&VerticalTilde", + "description": "Bad named entity: VerticalTilde without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&VerticalTilde" + ] + ] + }, + { + "input": "≀", + "description": "Named entity: VerticalTilde; with a semi-colon", + "output": [ + [ + "Character", + "\u2240" + ] + ] + }, + { + "input": "&VeryThinSpace", + "description": "Bad named entity: VeryThinSpace without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&VeryThinSpace" + ] + ] + }, + { + "input": " ", + "description": "Named entity: VeryThinSpace; with a semi-colon", + "output": [ + [ + "Character", + "\u200a" + ] + ] + }, + { + "input": "&Vfr", + "description": "Bad named entity: Vfr without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&Vfr" + ] + ] + }, + { + "input": "𝔙", + "description": "Named entity: Vfr; with a semi-colon", + "output": [ + [ + "Character", + "\ud835\udd19" + ] + ] + }, + { + "input": "&Vopf", + "description": "Bad named entity: Vopf without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&Vopf" + ] + ] + }, + { + "input": "𝕍", + "description": "Named entity: Vopf; with a semi-colon", + "output": [ + [ + "Character", + "\ud835\udd4d" + ] + ] + }, + { + "input": "&Vscr", + "description": "Bad named entity: Vscr without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&Vscr" + ] + ] + }, + { + "input": "𝒱", + "description": "Named entity: Vscr; with a semi-colon", + "output": [ + [ + "Character", + "\ud835\udcb1" + ] + ] + }, + { + "input": "&Vvdash", + "description": "Bad named entity: Vvdash without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&Vvdash" + ] + ] + }, + { + "input": "⊪", + "description": "Named entity: Vvdash; with a semi-colon", + "output": [ + [ + "Character", + "\u22aa" + ] + ] + }, + { + "input": "&Wcirc", + "description": "Bad named entity: Wcirc without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&Wcirc" + ] + ] + }, + { + "input": "Ŵ", + "description": "Named entity: Wcirc; with a semi-colon", + "output": [ + [ + "Character", + "\u0174" + ] + ] + }, + { + "input": "&Wedge", + "description": "Bad named entity: Wedge without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&Wedge" + ] + ] + }, + { + "input": "⋀", + "description": "Named entity: Wedge; with a semi-colon", + "output": [ + [ + "Character", + "\u22c0" + ] + ] + }, + { + "input": "&Wfr", + "description": "Bad named entity: Wfr without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&Wfr" + ] + ] + }, + { + "input": "𝔚", + "description": "Named entity: Wfr; with a semi-colon", + "output": [ + [ + "Character", + "\ud835\udd1a" + ] + ] + }, + { + "input": "&Wopf", + "description": "Bad named entity: Wopf without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&Wopf" + ] + ] + }, + { + "input": "𝕎", + "description": "Named entity: Wopf; with a semi-colon", + "output": [ + [ + "Character", + "\ud835\udd4e" + ] + ] + }, + { + "input": "&Wscr", + "description": "Bad named entity: Wscr without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&Wscr" + ] + ] + }, + { + "input": "𝒲", + "description": "Named entity: Wscr; with a semi-colon", + "output": [ + [ + "Character", + "\ud835\udcb2" + ] + ] + }, + { + "input": "&Xfr", + "description": "Bad named entity: Xfr without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&Xfr" + ] + ] + }, + { + "input": "𝔛", + "description": "Named entity: Xfr; with a semi-colon", + "output": [ + [ + "Character", + "\ud835\udd1b" + ] + ] + }, + { + "input": "&Xi", + "description": "Bad named entity: Xi without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&Xi" + ] + ] + }, + { + "input": "Ξ", + "description": "Named entity: Xi; with a semi-colon", + "output": [ + [ + "Character", + "\u039e" + ] + ] + }, + { + "input": "&Xopf", + "description": "Bad named entity: Xopf without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&Xopf" + ] + ] + }, + { + "input": "𝕏", + "description": "Named entity: Xopf; with a semi-colon", + "output": [ + [ + "Character", + "\ud835\udd4f" + ] + ] + }, + { + "input": "&Xscr", + "description": "Bad named entity: Xscr without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&Xscr" + ] + ] + }, + { + "input": "𝒳", + "description": "Named entity: Xscr; with a semi-colon", + "output": [ + [ + "Character", + "\ud835\udcb3" + ] + ] + }, + { + "input": "&YAcy", + "description": "Bad named entity: YAcy without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&YAcy" + ] + ] + }, + { + "input": "Я", + "description": "Named entity: YAcy; with a semi-colon", + "output": [ + [ + "Character", + "\u042f" + ] + ] + }, + { + "input": "&YIcy", + "description": "Bad named entity: YIcy without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&YIcy" + ] + ] + }, + { + "input": "Ї", + "description": "Named entity: YIcy; with a semi-colon", + "output": [ + [ + "Character", + "\u0407" + ] + ] + }, + { + "input": "&YUcy", + "description": "Bad named entity: YUcy without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&YUcy" + ] + ] + }, + { + "input": "Ю", + "description": "Named entity: YUcy; with a semi-colon", + "output": [ + [ + "Character", + "\u042e" + ] + ] + }, + { + "input": "Ý", + "description": "Named entity: Yacute without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "\u00dd" + ] + ] + }, + { + "input": "Ý", + "description": "Named entity: Yacute; with a semi-colon", + "output": [ + [ + "Character", + "\u00dd" + ] + ] + }, + { + "input": "&Ycirc", + "description": "Bad named entity: Ycirc without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&Ycirc" + ] + ] + }, + { + "input": "Ŷ", + "description": "Named entity: Ycirc; with a semi-colon", + "output": [ + [ + "Character", + "\u0176" + ] + ] + }, + { + "input": "&Ycy", + "description": "Bad named entity: Ycy without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&Ycy" + ] + ] + }, + { + "input": "Ы", + "description": "Named entity: Ycy; with a semi-colon", + "output": [ + [ + "Character", + "\u042b" + ] + ] + }, + { + "input": "&Yfr", + "description": "Bad named entity: Yfr without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&Yfr" + ] + ] + }, + { + "input": "𝔜", + "description": "Named entity: Yfr; with a semi-colon", + "output": [ + [ + "Character", + "\ud835\udd1c" + ] + ] + }, + { + "input": "&Yopf", + "description": "Bad named entity: Yopf without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&Yopf" + ] + ] + }, + { + "input": "𝕐", + "description": "Named entity: Yopf; with a semi-colon", + "output": [ + [ + "Character", + "\ud835\udd50" + ] + ] + }, + { + "input": "&Yscr", + "description": "Bad named entity: Yscr without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&Yscr" + ] + ] + }, + { + "input": "𝒴", + "description": "Named entity: Yscr; with a semi-colon", + "output": [ + [ + "Character", + "\ud835\udcb4" + ] + ] + }, + { + "input": "&Yuml", + "description": "Bad named entity: Yuml without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&Yuml" + ] + ] + }, + { + "input": "Ÿ", + "description": "Named entity: Yuml; with a semi-colon", + "output": [ + [ + "Character", + "\u0178" + ] + ] + }, + { + "input": "&ZHcy", + "description": "Bad named entity: ZHcy without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&ZHcy" + ] + ] + }, + { + "input": "Ж", + "description": "Named entity: ZHcy; with a semi-colon", + "output": [ + [ + "Character", + "\u0416" + ] + ] + }, + { + "input": "&Zacute", + "description": "Bad named entity: Zacute without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&Zacute" + ] + ] + }, + { + "input": "Ź", + "description": "Named entity: Zacute; with a semi-colon", + "output": [ + [ + "Character", + "\u0179" + ] + ] + }, + { + "input": "&Zcaron", + "description": "Bad named entity: Zcaron without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&Zcaron" + ] + ] + }, + { + "input": "Ž", + "description": "Named entity: Zcaron; with a semi-colon", + "output": [ + [ + "Character", + "\u017d" + ] + ] + }, + { + "input": "&Zcy", + "description": "Bad named entity: Zcy without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&Zcy" + ] + ] + }, + { + "input": "З", + "description": "Named entity: Zcy; with a semi-colon", + "output": [ + [ + "Character", + "\u0417" + ] + ] + }, + { + "input": "&Zdot", + "description": "Bad named entity: Zdot without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&Zdot" + ] + ] + }, + { + "input": "Ż", + "description": "Named entity: Zdot; with a semi-colon", + "output": [ + [ + "Character", + "\u017b" + ] + ] + }, + { + "input": "&ZeroWidthSpace", + "description": "Bad named entity: ZeroWidthSpace without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&ZeroWidthSpace" + ] + ] + }, + { + "input": "​", + "description": "Named entity: ZeroWidthSpace; with a semi-colon", + "output": [ + [ + "Character", + "\u200b" + ] + ] + }, + { + "input": "&Zeta", + "description": "Bad named entity: Zeta without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&Zeta" + ] + ] + }, + { + "input": "Ζ", + "description": "Named entity: Zeta; with a semi-colon", + "output": [ + [ + "Character", + "\u0396" + ] + ] + }, + { + "input": "&Zfr", + "description": "Bad named entity: Zfr without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&Zfr" + ] + ] + }, + { + "input": "ℨ", + "description": "Named entity: Zfr; with a semi-colon", + "output": [ + [ + "Character", + "\u2128" + ] + ] + }, + { + "input": "&Zopf", + "description": "Bad named entity: Zopf without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&Zopf" + ] + ] + }, + { + "input": "ℤ", + "description": "Named entity: Zopf; with a semi-colon", + "output": [ + [ + "Character", + "\u2124" + ] + ] + }, + { + "input": "&Zscr", + "description": "Bad named entity: Zscr without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&Zscr" + ] + ] + }, + { + "input": "𝒵", + "description": "Named entity: Zscr; with a semi-colon", + "output": [ + [ + "Character", + "\ud835\udcb5" + ] + ] + }, + { + "input": "á", + "description": "Named entity: aacute without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "\u00e1" + ] + ] + }, + { + "input": "á", + "description": "Named entity: aacute; with a semi-colon", + "output": [ + [ + "Character", + "\u00e1" + ] + ] + }, + { + "input": "&abreve", + "description": "Bad named entity: abreve without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&abreve" + ] + ] + }, + { + "input": "ă", + "description": "Named entity: abreve; with a semi-colon", + "output": [ + [ + "Character", + "\u0103" + ] + ] + }, + { + "input": "&ac", + "description": "Bad named entity: ac without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&ac" + ] + ] + }, + { + "input": "∾", + "description": "Named entity: ac; with a semi-colon", + "output": [ + [ + "Character", + "\u223e" + ] + ] + }, + { + "input": "&acE", + "description": "Bad named entity: acE without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&acE" + ] + ] + }, + { + "input": "∾̳", + "description": "Named entity: acE; with a semi-colon", + "output": [ + [ + "Character", + "\u223e\u0333" + ] + ] + }, + { + "input": "&acd", + "description": "Bad named entity: acd without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&acd" + ] + ] + }, + { + "input": "∿", + "description": "Named entity: acd; with a semi-colon", + "output": [ + [ + "Character", + "\u223f" + ] + ] + }, + { + "input": "â", + "description": "Named entity: acirc without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "\u00e2" + ] + ] + }, + { + "input": "â", + "description": "Named entity: acirc; with a semi-colon", + "output": [ + [ + "Character", + "\u00e2" + ] + ] + }, + { + "input": "´", + "description": "Named entity: acute without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "\u00b4" + ] + ] + }, + { + "input": "´", + "description": "Named entity: acute; with a semi-colon", + "output": [ + [ + "Character", + "\u00b4" + ] + ] + }, + { + "input": "&acy", + "description": "Bad named entity: acy without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&acy" + ] + ] + }, + { + "input": "а", + "description": "Named entity: acy; with a semi-colon", + "output": [ + [ + "Character", + "\u0430" + ] + ] + }, + { + "input": "æ", + "description": "Named entity: aelig without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "\u00e6" + ] + ] + }, + { + "input": "æ", + "description": "Named entity: aelig; with a semi-colon", + "output": [ + [ + "Character", + "\u00e6" + ] + ] + }, + { + "input": "&af", + "description": "Bad named entity: af without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&af" + ] + ] + }, + { + "input": "⁡", + "description": "Named entity: af; with a semi-colon", + "output": [ + [ + "Character", + "\u2061" + ] + ] + }, + { + "input": "&afr", + "description": "Bad named entity: afr without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&afr" + ] + ] + }, + { + "input": "𝔞", + "description": "Named entity: afr; with a semi-colon", + "output": [ + [ + "Character", + "\ud835\udd1e" + ] + ] + }, + { + "input": "à", + "description": "Named entity: agrave without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "\u00e0" + ] + ] + }, + { + "input": "à", + "description": "Named entity: agrave; with a semi-colon", + "output": [ + [ + "Character", + "\u00e0" + ] + ] + }, + { + "input": "&alefsym", + "description": "Bad named entity: alefsym without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&alefsym" + ] + ] + }, + { + "input": "ℵ", + "description": "Named entity: alefsym; with a semi-colon", + "output": [ + [ + "Character", + "\u2135" + ] + ] + }, + { + "input": "&aleph", + "description": "Bad named entity: aleph without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&aleph" + ] + ] + }, + { + "input": "ℵ", + "description": "Named entity: aleph; with a semi-colon", + "output": [ + [ + "Character", + "\u2135" + ] + ] + }, + { + "input": "&alpha", + "description": "Bad named entity: alpha without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&alpha" + ] + ] + }, + { + "input": "α", + "description": "Named entity: alpha; with a semi-colon", + "output": [ + [ + "Character", + "\u03b1" + ] + ] + }, + { + "input": "&amacr", + "description": "Bad named entity: amacr without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&amacr" + ] + ] + }, + { + "input": "ā", + "description": "Named entity: amacr; with a semi-colon", + "output": [ + [ + "Character", + "\u0101" + ] + ] + }, + { + "input": "&amalg", + "description": "Bad named entity: amalg without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&amalg" + ] + ] + }, + { + "input": "⨿", + "description": "Named entity: amalg; with a semi-colon", + "output": [ + [ + "Character", + "\u2a3f" + ] + ] + }, + { + "input": "&", + "description": "Named entity: amp without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&" + ] + ] + }, + { + "input": "&", + "description": "Named entity: amp; with a semi-colon", + "output": [ + [ + "Character", + "&" + ] + ] + }, + { + "input": "&and", + "description": "Bad named entity: and without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&and" + ] + ] + }, + { + "input": "∧", + "description": "Named entity: and; with a semi-colon", + "output": [ + [ + "Character", + "\u2227" + ] + ] + }, + { + "input": "&andand", + "description": "Bad named entity: andand without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&andand" + ] + ] + }, + { + "input": "⩕", + "description": "Named entity: andand; with a semi-colon", + "output": [ + [ + "Character", + "\u2a55" + ] + ] + }, + { + "input": "&andd", + "description": "Bad named entity: andd without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&andd" + ] + ] + }, + { + "input": "⩜", + "description": "Named entity: andd; with a semi-colon", + "output": [ + [ + "Character", + "\u2a5c" + ] + ] + }, + { + "input": "&andslope", + "description": "Bad named entity: andslope without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&andslope" + ] + ] + }, + { + "input": "⩘", + "description": "Named entity: andslope; with a semi-colon", + "output": [ + [ + "Character", + "\u2a58" + ] + ] + }, + { + "input": "&andv", + "description": "Bad named entity: andv without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&andv" + ] + ] + }, + { + "input": "⩚", + "description": "Named entity: andv; with a semi-colon", + "output": [ + [ + "Character", + "\u2a5a" + ] + ] + }, + { + "input": "&ang", + "description": "Bad named entity: ang without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&ang" + ] + ] + }, + { + "input": "∠", + "description": "Named entity: ang; with a semi-colon", + "output": [ + [ + "Character", + "\u2220" + ] + ] + }, + { + "input": "&ange", + "description": "Bad named entity: ange without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&ange" + ] + ] + }, + { + "input": "⦤", + "description": "Named entity: ange; with a semi-colon", + "output": [ + [ + "Character", + "\u29a4" + ] + ] + }, + { + "input": "&angle", + "description": "Bad named entity: angle without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&angle" + ] + ] + }, + { + "input": "∠", + "description": "Named entity: angle; with a semi-colon", + "output": [ + [ + "Character", + "\u2220" + ] + ] + }, + { + "input": "&angmsd", + "description": "Bad named entity: angmsd without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&angmsd" + ] + ] + }, + { + "input": "∡", + "description": "Named entity: angmsd; with a semi-colon", + "output": [ + [ + "Character", + "\u2221" + ] + ] + }, + { + "input": "&angmsdaa", + "description": "Bad named entity: angmsdaa without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&angmsdaa" + ] + ] + }, + { + "input": "⦨", + "description": "Named entity: angmsdaa; with a semi-colon", + "output": [ + [ + "Character", + "\u29a8" + ] + ] + }, + { + "input": "&angmsdab", + "description": "Bad named entity: angmsdab without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&angmsdab" + ] + ] + }, + { + "input": "⦩", + "description": "Named entity: angmsdab; with a semi-colon", + "output": [ + [ + "Character", + "\u29a9" + ] + ] + }, + { + "input": "&angmsdac", + "description": "Bad named entity: angmsdac without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&angmsdac" + ] + ] + }, + { + "input": "⦪", + "description": "Named entity: angmsdac; with a semi-colon", + "output": [ + [ + "Character", + "\u29aa" + ] + ] + }, + { + "input": "&angmsdad", + "description": "Bad named entity: angmsdad without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&angmsdad" + ] + ] + }, + { + "input": "⦫", + "description": "Named entity: angmsdad; with a semi-colon", + "output": [ + [ + "Character", + "\u29ab" + ] + ] + }, + { + "input": "&angmsdae", + "description": "Bad named entity: angmsdae without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&angmsdae" + ] + ] + }, + { + "input": "⦬", + "description": "Named entity: angmsdae; with a semi-colon", + "output": [ + [ + "Character", + "\u29ac" + ] + ] + }, + { + "input": "&angmsdaf", + "description": "Bad named entity: angmsdaf without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&angmsdaf" + ] + ] + }, + { + "input": "⦭", + "description": "Named entity: angmsdaf; with a semi-colon", + "output": [ + [ + "Character", + "\u29ad" + ] + ] + }, + { + "input": "&angmsdag", + "description": "Bad named entity: angmsdag without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&angmsdag" + ] + ] + }, + { + "input": "⦮", + "description": "Named entity: angmsdag; with a semi-colon", + "output": [ + [ + "Character", + "\u29ae" + ] + ] + }, + { + "input": "&angmsdah", + "description": "Bad named entity: angmsdah without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&angmsdah" + ] + ] + }, + { + "input": "⦯", + "description": "Named entity: angmsdah; with a semi-colon", + "output": [ + [ + "Character", + "\u29af" + ] + ] + }, + { + "input": "&angrt", + "description": "Bad named entity: angrt without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&angrt" + ] + ] + }, + { + "input": "∟", + "description": "Named entity: angrt; with a semi-colon", + "output": [ + [ + "Character", + "\u221f" + ] + ] + }, + { + "input": "&angrtvb", + "description": "Bad named entity: angrtvb without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&angrtvb" + ] + ] + }, + { + "input": "⊾", + "description": "Named entity: angrtvb; with a semi-colon", + "output": [ + [ + "Character", + "\u22be" + ] + ] + }, + { + "input": "&angrtvbd", + "description": "Bad named entity: angrtvbd without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&angrtvbd" + ] + ] + }, + { + "input": "⦝", + "description": "Named entity: angrtvbd; with a semi-colon", + "output": [ + [ + "Character", + "\u299d" + ] + ] + }, + { + "input": "&angsph", + "description": "Bad named entity: angsph without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&angsph" + ] + ] + }, + { + "input": "∢", + "description": "Named entity: angsph; with a semi-colon", + "output": [ + [ + "Character", + "\u2222" + ] + ] + }, + { + "input": "&angst", + "description": "Bad named entity: angst without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&angst" + ] + ] + }, + { + "input": "Å", + "description": "Named entity: angst; with a semi-colon", + "output": [ + [ + "Character", + "\u00c5" + ] + ] + }, + { + "input": "&angzarr", + "description": "Bad named entity: angzarr without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&angzarr" + ] + ] + }, + { + "input": "⍼", + "description": "Named entity: angzarr; with a semi-colon", + "output": [ + [ + "Character", + "\u237c" + ] + ] + }, + { + "input": "&aogon", + "description": "Bad named entity: aogon without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&aogon" + ] + ] + }, + { + "input": "ą", + "description": "Named entity: aogon; with a semi-colon", + "output": [ + [ + "Character", + "\u0105" + ] + ] + }, + { + "input": "&aopf", + "description": "Bad named entity: aopf without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&aopf" + ] + ] + }, + { + "input": "𝕒", + "description": "Named entity: aopf; with a semi-colon", + "output": [ + [ + "Character", + "\ud835\udd52" + ] + ] + }, + { + "input": "&ap", + "description": "Bad named entity: ap without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&ap" + ] + ] + }, + { + "input": "≈", + "description": "Named entity: ap; with a semi-colon", + "output": [ + [ + "Character", + "\u2248" + ] + ] + }, + { + "input": "&apE", + "description": "Bad named entity: apE without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&apE" + ] + ] + }, + { + "input": "⩰", + "description": "Named entity: apE; with a semi-colon", + "output": [ + [ + "Character", + "\u2a70" + ] + ] + }, + { + "input": "&apacir", + "description": "Bad named entity: apacir without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&apacir" + ] + ] + }, + { + "input": "⩯", + "description": "Named entity: apacir; with a semi-colon", + "output": [ + [ + "Character", + "\u2a6f" + ] + ] + }, + { + "input": "&ape", + "description": "Bad named entity: ape without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&ape" + ] + ] + }, + { + "input": "≊", + "description": "Named entity: ape; with a semi-colon", + "output": [ + [ + "Character", + "\u224a" + ] + ] + }, + { + "input": "&apid", + "description": "Bad named entity: apid without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&apid" + ] + ] + }, + { + "input": "≋", + "description": "Named entity: apid; with a semi-colon", + "output": [ + [ + "Character", + "\u224b" + ] + ] + }, + { + "input": "&apos", + "description": "Bad named entity: apos without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&apos" + ] + ] + }, + { + "input": "'", + "description": "Named entity: apos; with a semi-colon", + "output": [ + [ + "Character", + "'" + ] + ] + }, + { + "input": "&approx", + "description": "Bad named entity: approx without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&approx" + ] + ] + }, + { + "input": "≈", + "description": "Named entity: approx; with a semi-colon", + "output": [ + [ + "Character", + "\u2248" + ] + ] + }, + { + "input": "&approxeq", + "description": "Bad named entity: approxeq without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&approxeq" + ] + ] + }, + { + "input": "≊", + "description": "Named entity: approxeq; with a semi-colon", + "output": [ + [ + "Character", + "\u224a" + ] + ] + }, + { + "input": "å", + "description": "Named entity: aring without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "\u00e5" + ] + ] + }, + { + "input": "å", + "description": "Named entity: aring; with a semi-colon", + "output": [ + [ + "Character", + "\u00e5" + ] + ] + }, + { + "input": "&ascr", + "description": "Bad named entity: ascr without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&ascr" + ] + ] + }, + { + "input": "𝒶", + "description": "Named entity: ascr; with a semi-colon", + "output": [ + [ + "Character", + "\ud835\udcb6" + ] + ] + }, + { + "input": "&ast", + "description": "Bad named entity: ast without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&ast" + ] + ] + }, + { + "input": "*", + "description": "Named entity: ast; with a semi-colon", + "output": [ + [ + "Character", + "*" + ] + ] + }, + { + "input": "&asymp", + "description": "Bad named entity: asymp without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&asymp" + ] + ] + }, + { + "input": "≈", + "description": "Named entity: asymp; with a semi-colon", + "output": [ + [ + "Character", + "\u2248" + ] + ] + }, + { + "input": "&asympeq", + "description": "Bad named entity: asympeq without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&asympeq" + ] + ] + }, + { + "input": "≍", + "description": "Named entity: asympeq; with a semi-colon", + "output": [ + [ + "Character", + "\u224d" + ] + ] + }, + { + "input": "ã", + "description": "Named entity: atilde without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "\u00e3" + ] + ] + }, + { + "input": "ã", + "description": "Named entity: atilde; with a semi-colon", + "output": [ + [ + "Character", + "\u00e3" + ] + ] + }, + { + "input": "ä", + "description": "Named entity: auml without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "\u00e4" + ] + ] + }, + { + "input": "ä", + "description": "Named entity: auml; with a semi-colon", + "output": [ + [ + "Character", + "\u00e4" + ] + ] + }, + { + "input": "&awconint", + "description": "Bad named entity: awconint without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&awconint" + ] + ] + }, + { + "input": "∳", + "description": "Named entity: awconint; with a semi-colon", + "output": [ + [ + "Character", + "\u2233" + ] + ] + }, + { + "input": "&awint", + "description": "Bad named entity: awint without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&awint" + ] + ] + }, + { + "input": "⨑", + "description": "Named entity: awint; with a semi-colon", + "output": [ + [ + "Character", + "\u2a11" + ] + ] + }, + { + "input": "&bNot", + "description": "Bad named entity: bNot without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&bNot" + ] + ] + }, + { + "input": "⫭", + "description": "Named entity: bNot; with a semi-colon", + "output": [ + [ + "Character", + "\u2aed" + ] + ] + }, + { + "input": "&backcong", + "description": "Bad named entity: backcong without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&backcong" + ] + ] + }, + { + "input": "≌", + "description": "Named entity: backcong; with a semi-colon", + "output": [ + [ + "Character", + "\u224c" + ] + ] + }, + { + "input": "&backepsilon", + "description": "Bad named entity: backepsilon without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&backepsilon" + ] + ] + }, + { + "input": "϶", + "description": "Named entity: backepsilon; with a semi-colon", + "output": [ + [ + "Character", + "\u03f6" + ] + ] + }, + { + "input": "&backprime", + "description": "Bad named entity: backprime without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&backprime" + ] + ] + }, + { + "input": "‵", + "description": "Named entity: backprime; with a semi-colon", + "output": [ + [ + "Character", + "\u2035" + ] + ] + }, + { + "input": "&backsim", + "description": "Bad named entity: backsim without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&backsim" + ] + ] + }, + { + "input": "∽", + "description": "Named entity: backsim; with a semi-colon", + "output": [ + [ + "Character", + "\u223d" + ] + ] + }, + { + "input": "&backsimeq", + "description": "Bad named entity: backsimeq without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&backsimeq" + ] + ] + }, + { + "input": "⋍", + "description": "Named entity: backsimeq; with a semi-colon", + "output": [ + [ + "Character", + "\u22cd" + ] + ] + }, + { + "input": "&barvee", + "description": "Bad named entity: barvee without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&barvee" + ] + ] + }, + { + "input": "⊽", + "description": "Named entity: barvee; with a semi-colon", + "output": [ + [ + "Character", + "\u22bd" + ] + ] + }, + { + "input": "&barwed", + "description": "Bad named entity: barwed without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&barwed" + ] + ] + }, + { + "input": "⌅", + "description": "Named entity: barwed; with a semi-colon", + "output": [ + [ + "Character", + "\u2305" + ] + ] + }, + { + "input": "&barwedge", + "description": "Bad named entity: barwedge without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&barwedge" + ] + ] + }, + { + "input": "⌅", + "description": "Named entity: barwedge; with a semi-colon", + "output": [ + [ + "Character", + "\u2305" + ] + ] + }, + { + "input": "&bbrk", + "description": "Bad named entity: bbrk without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&bbrk" + ] + ] + }, + { + "input": "⎵", + "description": "Named entity: bbrk; with a semi-colon", + "output": [ + [ + "Character", + "\u23b5" + ] + ] + }, + { + "input": "&bbrktbrk", + "description": "Bad named entity: bbrktbrk without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&bbrktbrk" + ] + ] + }, + { + "input": "⎶", + "description": "Named entity: bbrktbrk; with a semi-colon", + "output": [ + [ + "Character", + "\u23b6" + ] + ] + }, + { + "input": "&bcong", + "description": "Bad named entity: bcong without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&bcong" + ] + ] + }, + { + "input": "≌", + "description": "Named entity: bcong; with a semi-colon", + "output": [ + [ + "Character", + "\u224c" + ] + ] + }, + { + "input": "&bcy", + "description": "Bad named entity: bcy without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&bcy" + ] + ] + }, + { + "input": "б", + "description": "Named entity: bcy; with a semi-colon", + "output": [ + [ + "Character", + "\u0431" + ] + ] + }, + { + "input": "&bdquo", + "description": "Bad named entity: bdquo without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&bdquo" + ] + ] + }, + { + "input": "„", + "description": "Named entity: bdquo; with a semi-colon", + "output": [ + [ + "Character", + "\u201e" + ] + ] + }, + { + "input": "&becaus", + "description": "Bad named entity: becaus without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&becaus" + ] + ] + }, + { + "input": "∵", + "description": "Named entity: becaus; with a semi-colon", + "output": [ + [ + "Character", + "\u2235" + ] + ] + }, + { + "input": "&because", + "description": "Bad named entity: because without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&because" + ] + ] + }, + { + "input": "∵", + "description": "Named entity: because; with a semi-colon", + "output": [ + [ + "Character", + "\u2235" + ] + ] + }, + { + "input": "&bemptyv", + "description": "Bad named entity: bemptyv without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&bemptyv" + ] + ] + }, + { + "input": "⦰", + "description": "Named entity: bemptyv; with a semi-colon", + "output": [ + [ + "Character", + "\u29b0" + ] + ] + }, + { + "input": "&bepsi", + "description": "Bad named entity: bepsi without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&bepsi" + ] + ] + }, + { + "input": "϶", + "description": "Named entity: bepsi; with a semi-colon", + "output": [ + [ + "Character", + "\u03f6" + ] + ] + }, + { + "input": "&bernou", + "description": "Bad named entity: bernou without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&bernou" + ] + ] + }, + { + "input": "ℬ", + "description": "Named entity: bernou; with a semi-colon", + "output": [ + [ + "Character", + "\u212c" + ] + ] + }, + { + "input": "&beta", + "description": "Bad named entity: beta without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&beta" + ] + ] + }, + { + "input": "β", + "description": "Named entity: beta; with a semi-colon", + "output": [ + [ + "Character", + "\u03b2" + ] + ] + }, + { + "input": "&beth", + "description": "Bad named entity: beth without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&beth" + ] + ] + }, + { + "input": "ℶ", + "description": "Named entity: beth; with a semi-colon", + "output": [ + [ + "Character", + "\u2136" + ] + ] + }, + { + "input": "&between", + "description": "Bad named entity: between without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&between" + ] + ] + }, + { + "input": "≬", + "description": "Named entity: between; with a semi-colon", + "output": [ + [ + "Character", + "\u226c" + ] + ] + }, + { + "input": "&bfr", + "description": "Bad named entity: bfr without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&bfr" + ] + ] + }, + { + "input": "𝔟", + "description": "Named entity: bfr; with a semi-colon", + "output": [ + [ + "Character", + "\ud835\udd1f" + ] + ] + }, + { + "input": "&bigcap", + "description": "Bad named entity: bigcap without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&bigcap" + ] + ] + }, + { + "input": "⋂", + "description": "Named entity: bigcap; with a semi-colon", + "output": [ + [ + "Character", + "\u22c2" + ] + ] + }, + { + "input": "&bigcirc", + "description": "Bad named entity: bigcirc without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&bigcirc" + ] + ] + }, + { + "input": "◯", + "description": "Named entity: bigcirc; with a semi-colon", + "output": [ + [ + "Character", + "\u25ef" + ] + ] + }, + { + "input": "&bigcup", + "description": "Bad named entity: bigcup without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&bigcup" + ] + ] + }, + { + "input": "⋃", + "description": "Named entity: bigcup; with a semi-colon", + "output": [ + [ + "Character", + "\u22c3" + ] + ] + }, + { + "input": "&bigodot", + "description": "Bad named entity: bigodot without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&bigodot" + ] + ] + }, + { + "input": "⨀", + "description": "Named entity: bigodot; with a semi-colon", + "output": [ + [ + "Character", + "\u2a00" + ] + ] + }, + { + "input": "&bigoplus", + "description": "Bad named entity: bigoplus without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&bigoplus" + ] + ] + }, + { + "input": "⨁", + "description": "Named entity: bigoplus; with a semi-colon", + "output": [ + [ + "Character", + "\u2a01" + ] + ] + }, + { + "input": "&bigotimes", + "description": "Bad named entity: bigotimes without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&bigotimes" + ] + ] + }, + { + "input": "⨂", + "description": "Named entity: bigotimes; with a semi-colon", + "output": [ + [ + "Character", + "\u2a02" + ] + ] + }, + { + "input": "&bigsqcup", + "description": "Bad named entity: bigsqcup without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&bigsqcup" + ] + ] + }, + { + "input": "⨆", + "description": "Named entity: bigsqcup; with a semi-colon", + "output": [ + [ + "Character", + "\u2a06" + ] + ] + }, + { + "input": "&bigstar", + "description": "Bad named entity: bigstar without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&bigstar" + ] + ] + }, + { + "input": "★", + "description": "Named entity: bigstar; with a semi-colon", + "output": [ + [ + "Character", + "\u2605" + ] + ] + }, + { + "input": "&bigtriangledown", + "description": "Bad named entity: bigtriangledown without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&bigtriangledown" + ] + ] + }, + { + "input": "▽", + "description": "Named entity: bigtriangledown; with a semi-colon", + "output": [ + [ + "Character", + "\u25bd" + ] + ] + }, + { + "input": "&bigtriangleup", + "description": "Bad named entity: bigtriangleup without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&bigtriangleup" + ] + ] + }, + { + "input": "△", + "description": "Named entity: bigtriangleup; with a semi-colon", + "output": [ + [ + "Character", + "\u25b3" + ] + ] + }, + { + "input": "&biguplus", + "description": "Bad named entity: biguplus without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&biguplus" + ] + ] + }, + { + "input": "⨄", + "description": "Named entity: biguplus; with a semi-colon", + "output": [ + [ + "Character", + "\u2a04" + ] + ] + }, + { + "input": "&bigvee", + "description": "Bad named entity: bigvee without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&bigvee" + ] + ] + }, + { + "input": "⋁", + "description": "Named entity: bigvee; with a semi-colon", + "output": [ + [ + "Character", + "\u22c1" + ] + ] + }, + { + "input": "&bigwedge", + "description": "Bad named entity: bigwedge without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&bigwedge" + ] + ] + }, + { + "input": "⋀", + "description": "Named entity: bigwedge; with a semi-colon", + "output": [ + [ + "Character", + "\u22c0" + ] + ] + }, + { + "input": "&bkarow", + "description": "Bad named entity: bkarow without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&bkarow" + ] + ] + }, + { + "input": "⤍", + "description": "Named entity: bkarow; with a semi-colon", + "output": [ + [ + "Character", + "\u290d" + ] + ] + }, + { + "input": "&blacklozenge", + "description": "Bad named entity: blacklozenge without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&blacklozenge" + ] + ] + }, + { + "input": "⧫", + "description": "Named entity: blacklozenge; with a semi-colon", + "output": [ + [ + "Character", + "\u29eb" + ] + ] + }, + { + "input": "&blacksquare", + "description": "Bad named entity: blacksquare without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&blacksquare" + ] + ] + }, + { + "input": "▪", + "description": "Named entity: blacksquare; with a semi-colon", + "output": [ + [ + "Character", + "\u25aa" + ] + ] + }, + { + "input": "&blacktriangle", + "description": "Bad named entity: blacktriangle without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&blacktriangle" + ] + ] + }, + { + "input": "▴", + "description": "Named entity: blacktriangle; with a semi-colon", + "output": [ + [ + "Character", + "\u25b4" + ] + ] + }, + { + "input": "&blacktriangledown", + "description": "Bad named entity: blacktriangledown without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&blacktriangledown" + ] + ] + }, + { + "input": "▾", + "description": "Named entity: blacktriangledown; with a semi-colon", + "output": [ + [ + "Character", + "\u25be" + ] + ] + }, + { + "input": "&blacktriangleleft", + "description": "Bad named entity: blacktriangleleft without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&blacktriangleleft" + ] + ] + }, + { + "input": "◂", + "description": "Named entity: blacktriangleleft; with a semi-colon", + "output": [ + [ + "Character", + "\u25c2" + ] + ] + }, + { + "input": "&blacktriangleright", + "description": "Bad named entity: blacktriangleright without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&blacktriangleright" + ] + ] + }, + { + "input": "▸", + "description": "Named entity: blacktriangleright; with a semi-colon", + "output": [ + [ + "Character", + "\u25b8" + ] + ] + }, + { + "input": "&blank", + "description": "Bad named entity: blank without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&blank" + ] + ] + }, + { + "input": "␣", + "description": "Named entity: blank; with a semi-colon", + "output": [ + [ + "Character", + "\u2423" + ] + ] + }, + { + "input": "&blk12", + "description": "Bad named entity: blk12 without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&blk12" + ] + ] + }, + { + "input": "▒", + "description": "Named entity: blk12; with a semi-colon", + "output": [ + [ + "Character", + "\u2592" + ] + ] + }, + { + "input": "&blk14", + "description": "Bad named entity: blk14 without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&blk14" + ] + ] + }, + { + "input": "░", + "description": "Named entity: blk14; with a semi-colon", + "output": [ + [ + "Character", + "\u2591" + ] + ] + }, + { + "input": "&blk34", + "description": "Bad named entity: blk34 without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&blk34" + ] + ] + }, + { + "input": "▓", + "description": "Named entity: blk34; with a semi-colon", + "output": [ + [ + "Character", + "\u2593" + ] + ] + }, + { + "input": "&block", + "description": "Bad named entity: block without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&block" + ] + ] + }, + { + "input": "█", + "description": "Named entity: block; with a semi-colon", + "output": [ + [ + "Character", + "\u2588" + ] + ] + }, + { + "input": "&bne", + "description": "Bad named entity: bne without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&bne" + ] + ] + }, + { + "input": "=⃥", + "description": "Named entity: bne; with a semi-colon", + "output": [ + [ + "Character", + "=\u20e5" + ] + ] + }, + { + "input": "&bnequiv", + "description": "Bad named entity: bnequiv without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&bnequiv" + ] + ] + }, + { + "input": "≡⃥", + "description": "Named entity: bnequiv; with a semi-colon", + "output": [ + [ + "Character", + "\u2261\u20e5" + ] + ] + }, + { + "input": "&bnot", + "description": "Bad named entity: bnot without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&bnot" + ] + ] + }, + { + "input": "⌐", + "description": "Named entity: bnot; with a semi-colon", + "output": [ + [ + "Character", + "\u2310" + ] + ] + }, + { + "input": "&bopf", + "description": "Bad named entity: bopf without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&bopf" + ] + ] + }, + { + "input": "𝕓", + "description": "Named entity: bopf; with a semi-colon", + "output": [ + [ + "Character", + "\ud835\udd53" + ] + ] + }, + { + "input": "&bot", + "description": "Bad named entity: bot without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&bot" + ] + ] + }, + { + "input": "⊥", + "description": "Named entity: bot; with a semi-colon", + "output": [ + [ + "Character", + "\u22a5" + ] + ] + }, + { + "input": "&bottom", + "description": "Bad named entity: bottom without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&bottom" + ] + ] + }, + { + "input": "⊥", + "description": "Named entity: bottom; with a semi-colon", + "output": [ + [ + "Character", + "\u22a5" + ] + ] + }, + { + "input": "&bowtie", + "description": "Bad named entity: bowtie without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&bowtie" + ] + ] + }, + { + "input": "⋈", + "description": "Named entity: bowtie; with a semi-colon", + "output": [ + [ + "Character", + "\u22c8" + ] + ] + }, + { + "input": "&boxDL", + "description": "Bad named entity: boxDL without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&boxDL" + ] + ] + }, + { + "input": "╗", + "description": "Named entity: boxDL; with a semi-colon", + "output": [ + [ + "Character", + "\u2557" + ] + ] + }, + { + "input": "&boxDR", + "description": "Bad named entity: boxDR without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&boxDR" + ] + ] + }, + { + "input": "╔", + "description": "Named entity: boxDR; with a semi-colon", + "output": [ + [ + "Character", + "\u2554" + ] + ] + }, + { + "input": "&boxDl", + "description": "Bad named entity: boxDl without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&boxDl" + ] + ] + }, + { + "input": "╖", + "description": "Named entity: boxDl; with a semi-colon", + "output": [ + [ + "Character", + "\u2556" + ] + ] + }, + { + "input": "&boxDr", + "description": "Bad named entity: boxDr without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&boxDr" + ] + ] + }, + { + "input": "╓", + "description": "Named entity: boxDr; with a semi-colon", + "output": [ + [ + "Character", + "\u2553" + ] + ] + }, + { + "input": "&boxH", + "description": "Bad named entity: boxH without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&boxH" + ] + ] + }, + { + "input": "═", + "description": "Named entity: boxH; with a semi-colon", + "output": [ + [ + "Character", + "\u2550" + ] + ] + }, + { + "input": "&boxHD", + "description": "Bad named entity: boxHD without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&boxHD" + ] + ] + }, + { + "input": "╦", + "description": "Named entity: boxHD; with a semi-colon", + "output": [ + [ + "Character", + "\u2566" + ] + ] + }, + { + "input": "&boxHU", + "description": "Bad named entity: boxHU without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&boxHU" + ] + ] + }, + { + "input": "╩", + "description": "Named entity: boxHU; with a semi-colon", + "output": [ + [ + "Character", + "\u2569" + ] + ] + }, + { + "input": "&boxHd", + "description": "Bad named entity: boxHd without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&boxHd" + ] + ] + }, + { + "input": "╤", + "description": "Named entity: boxHd; with a semi-colon", + "output": [ + [ + "Character", + "\u2564" + ] + ] + }, + { + "input": "&boxHu", + "description": "Bad named entity: boxHu without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&boxHu" + ] + ] + }, + { + "input": "╧", + "description": "Named entity: boxHu; with a semi-colon", + "output": [ + [ + "Character", + "\u2567" + ] + ] + }, + { + "input": "&boxUL", + "description": "Bad named entity: boxUL without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&boxUL" + ] + ] + }, + { + "input": "╝", + "description": "Named entity: boxUL; with a semi-colon", + "output": [ + [ + "Character", + "\u255d" + ] + ] + }, + { + "input": "&boxUR", + "description": "Bad named entity: boxUR without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&boxUR" + ] + ] + }, + { + "input": "╚", + "description": "Named entity: boxUR; with a semi-colon", + "output": [ + [ + "Character", + "\u255a" + ] + ] + }, + { + "input": "&boxUl", + "description": "Bad named entity: boxUl without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&boxUl" + ] + ] + }, + { + "input": "╜", + "description": "Named entity: boxUl; with a semi-colon", + "output": [ + [ + "Character", + "\u255c" + ] + ] + }, + { + "input": "&boxUr", + "description": "Bad named entity: boxUr without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&boxUr" + ] + ] + }, + { + "input": "╙", + "description": "Named entity: boxUr; with a semi-colon", + "output": [ + [ + "Character", + "\u2559" + ] + ] + }, + { + "input": "&boxV", + "description": "Bad named entity: boxV without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&boxV" + ] + ] + }, + { + "input": "║", + "description": "Named entity: boxV; with a semi-colon", + "output": [ + [ + "Character", + "\u2551" + ] + ] + }, + { + "input": "&boxVH", + "description": "Bad named entity: boxVH without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&boxVH" + ] + ] + }, + { + "input": "╬", + "description": "Named entity: boxVH; with a semi-colon", + "output": [ + [ + "Character", + "\u256c" + ] + ] + }, + { + "input": "&boxVL", + "description": "Bad named entity: boxVL without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&boxVL" + ] + ] + }, + { + "input": "╣", + "description": "Named entity: boxVL; with a semi-colon", + "output": [ + [ + "Character", + "\u2563" + ] + ] + }, + { + "input": "&boxVR", + "description": "Bad named entity: boxVR without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&boxVR" + ] + ] + }, + { + "input": "╠", + "description": "Named entity: boxVR; with a semi-colon", + "output": [ + [ + "Character", + "\u2560" + ] + ] + }, + { + "input": "&boxVh", + "description": "Bad named entity: boxVh without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&boxVh" + ] + ] + }, + { + "input": "╫", + "description": "Named entity: boxVh; with a semi-colon", + "output": [ + [ + "Character", + "\u256b" + ] + ] + }, + { + "input": "&boxVl", + "description": "Bad named entity: boxVl without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&boxVl" + ] + ] + }, + { + "input": "╢", + "description": "Named entity: boxVl; with a semi-colon", + "output": [ + [ + "Character", + "\u2562" + ] + ] + }, + { + "input": "&boxVr", + "description": "Bad named entity: boxVr without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&boxVr" + ] + ] + }, + { + "input": "╟", + "description": "Named entity: boxVr; with a semi-colon", + "output": [ + [ + "Character", + "\u255f" + ] + ] + }, + { + "input": "&boxbox", + "description": "Bad named entity: boxbox without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&boxbox" + ] + ] + }, + { + "input": "⧉", + "description": "Named entity: boxbox; with a semi-colon", + "output": [ + [ + "Character", + "\u29c9" + ] + ] + }, + { + "input": "&boxdL", + "description": "Bad named entity: boxdL without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&boxdL" + ] + ] + }, + { + "input": "╕", + "description": "Named entity: boxdL; with a semi-colon", + "output": [ + [ + "Character", + "\u2555" + ] + ] + }, + { + "input": "&boxdR", + "description": "Bad named entity: boxdR without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&boxdR" + ] + ] + }, + { + "input": "╒", + "description": "Named entity: boxdR; with a semi-colon", + "output": [ + [ + "Character", + "\u2552" + ] + ] + }, + { + "input": "&boxdl", + "description": "Bad named entity: boxdl without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&boxdl" + ] + ] + }, + { + "input": "┐", + "description": "Named entity: boxdl; with a semi-colon", + "output": [ + [ + "Character", + "\u2510" + ] + ] + }, + { + "input": "&boxdr", + "description": "Bad named entity: boxdr without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&boxdr" + ] + ] + }, + { + "input": "┌", + "description": "Named entity: boxdr; with a semi-colon", + "output": [ + [ + "Character", + "\u250c" + ] + ] + }, + { + "input": "&boxh", + "description": "Bad named entity: boxh without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&boxh" + ] + ] + }, + { + "input": "─", + "description": "Named entity: boxh; with a semi-colon", + "output": [ + [ + "Character", + "\u2500" + ] + ] + }, + { + "input": "&boxhD", + "description": "Bad named entity: boxhD without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&boxhD" + ] + ] + }, + { + "input": "╥", + "description": "Named entity: boxhD; with a semi-colon", + "output": [ + [ + "Character", + "\u2565" + ] + ] + }, + { + "input": "&boxhU", + "description": "Bad named entity: boxhU without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&boxhU" + ] + ] + }, + { + "input": "╨", + "description": "Named entity: boxhU; with a semi-colon", + "output": [ + [ + "Character", + "\u2568" + ] + ] + }, + { + "input": "&boxhd", + "description": "Bad named entity: boxhd without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&boxhd" + ] + ] + }, + { + "input": "┬", + "description": "Named entity: boxhd; with a semi-colon", + "output": [ + [ + "Character", + "\u252c" + ] + ] + }, + { + "input": "&boxhu", + "description": "Bad named entity: boxhu without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&boxhu" + ] + ] + }, + { + "input": "┴", + "description": "Named entity: boxhu; with a semi-colon", + "output": [ + [ + "Character", + "\u2534" + ] + ] + }, + { + "input": "&boxminus", + "description": "Bad named entity: boxminus without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&boxminus" + ] + ] + }, + { + "input": "⊟", + "description": "Named entity: boxminus; with a semi-colon", + "output": [ + [ + "Character", + "\u229f" + ] + ] + }, + { + "input": "&boxplus", + "description": "Bad named entity: boxplus without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&boxplus" + ] + ] + }, + { + "input": "⊞", + "description": "Named entity: boxplus; with a semi-colon", + "output": [ + [ + "Character", + "\u229e" + ] + ] + }, + { + "input": "&boxtimes", + "description": "Bad named entity: boxtimes without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&boxtimes" + ] + ] + }, + { + "input": "⊠", + "description": "Named entity: boxtimes; with a semi-colon", + "output": [ + [ + "Character", + "\u22a0" + ] + ] + }, + { + "input": "&boxuL", + "description": "Bad named entity: boxuL without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&boxuL" + ] + ] + }, + { + "input": "╛", + "description": "Named entity: boxuL; with a semi-colon", + "output": [ + [ + "Character", + "\u255b" + ] + ] + }, + { + "input": "&boxuR", + "description": "Bad named entity: boxuR without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&boxuR" + ] + ] + }, + { + "input": "╘", + "description": "Named entity: boxuR; with a semi-colon", + "output": [ + [ + "Character", + "\u2558" + ] + ] + }, + { + "input": "&boxul", + "description": "Bad named entity: boxul without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&boxul" + ] + ] + }, + { + "input": "┘", + "description": "Named entity: boxul; with a semi-colon", + "output": [ + [ + "Character", + "\u2518" + ] + ] + }, + { + "input": "&boxur", + "description": "Bad named entity: boxur without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&boxur" + ] + ] + }, + { + "input": "└", + "description": "Named entity: boxur; with a semi-colon", + "output": [ + [ + "Character", + "\u2514" + ] + ] + }, + { + "input": "&boxv", + "description": "Bad named entity: boxv without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&boxv" + ] + ] + }, + { + "input": "│", + "description": "Named entity: boxv; with a semi-colon", + "output": [ + [ + "Character", + "\u2502" + ] + ] + }, + { + "input": "&boxvH", + "description": "Bad named entity: boxvH without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&boxvH" + ] + ] + }, + { + "input": "╪", + "description": "Named entity: boxvH; with a semi-colon", + "output": [ + [ + "Character", + "\u256a" + ] + ] + }, + { + "input": "&boxvL", + "description": "Bad named entity: boxvL without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&boxvL" + ] + ] + }, + { + "input": "╡", + "description": "Named entity: boxvL; with a semi-colon", + "output": [ + [ + "Character", + "\u2561" + ] + ] + }, + { + "input": "&boxvR", + "description": "Bad named entity: boxvR without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&boxvR" + ] + ] + }, + { + "input": "╞", + "description": "Named entity: boxvR; with a semi-colon", + "output": [ + [ + "Character", + "\u255e" + ] + ] + }, + { + "input": "&boxvh", + "description": "Bad named entity: boxvh without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&boxvh" + ] + ] + }, + { + "input": "┼", + "description": "Named entity: boxvh; with a semi-colon", + "output": [ + [ + "Character", + "\u253c" + ] + ] + }, + { + "input": "&boxvl", + "description": "Bad named entity: boxvl without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&boxvl" + ] + ] + }, + { + "input": "┤", + "description": "Named entity: boxvl; with a semi-colon", + "output": [ + [ + "Character", + "\u2524" + ] + ] + }, + { + "input": "&boxvr", + "description": "Bad named entity: boxvr without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&boxvr" + ] + ] + }, + { + "input": "├", + "description": "Named entity: boxvr; with a semi-colon", + "output": [ + [ + "Character", + "\u251c" + ] + ] + }, + { + "input": "&bprime", + "description": "Bad named entity: bprime without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&bprime" + ] + ] + }, + { + "input": "‵", + "description": "Named entity: bprime; with a semi-colon", + "output": [ + [ + "Character", + "\u2035" + ] + ] + }, + { + "input": "&breve", + "description": "Bad named entity: breve without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&breve" + ] + ] + }, + { + "input": "˘", + "description": "Named entity: breve; with a semi-colon", + "output": [ + [ + "Character", + "\u02d8" + ] + ] + }, + { + "input": "¦", + "description": "Named entity: brvbar without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "\u00a6" + ] + ] + }, + { + "input": "¦", + "description": "Named entity: brvbar; with a semi-colon", + "output": [ + [ + "Character", + "\u00a6" + ] + ] + }, + { + "input": "&bscr", + "description": "Bad named entity: bscr without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&bscr" + ] + ] + }, + { + "input": "𝒷", + "description": "Named entity: bscr; with a semi-colon", + "output": [ + [ + "Character", + "\ud835\udcb7" + ] + ] + }, + { + "input": "&bsemi", + "description": "Bad named entity: bsemi without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&bsemi" + ] + ] + }, + { + "input": "⁏", + "description": "Named entity: bsemi; with a semi-colon", + "output": [ + [ + "Character", + "\u204f" + ] + ] + }, + { + "input": "&bsim", + "description": "Bad named entity: bsim without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&bsim" + ] + ] + }, + { + "input": "∽", + "description": "Named entity: bsim; with a semi-colon", + "output": [ + [ + "Character", + "\u223d" + ] + ] + }, + { + "input": "&bsime", + "description": "Bad named entity: bsime without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&bsime" + ] + ] + }, + { + "input": "⋍", + "description": "Named entity: bsime; with a semi-colon", + "output": [ + [ + "Character", + "\u22cd" + ] + ] + }, + { + "input": "&bsol", + "description": "Bad named entity: bsol without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&bsol" + ] + ] + }, + { + "input": "\", + "description": "Named entity: bsol; with a semi-colon", + "output": [ + [ + "Character", + "\\" + ] + ] + }, + { + "input": "&bsolb", + "description": "Bad named entity: bsolb without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&bsolb" + ] + ] + }, + { + "input": "⧅", + "description": "Named entity: bsolb; with a semi-colon", + "output": [ + [ + "Character", + "\u29c5" + ] + ] + }, + { + "input": "&bsolhsub", + "description": "Bad named entity: bsolhsub without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&bsolhsub" + ] + ] + }, + { + "input": "⟈", + "description": "Named entity: bsolhsub; with a semi-colon", + "output": [ + [ + "Character", + "\u27c8" + ] + ] + }, + { + "input": "&bull", + "description": "Bad named entity: bull without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&bull" + ] + ] + }, + { + "input": "•", + "description": "Named entity: bull; with a semi-colon", + "output": [ + [ + "Character", + "\u2022" + ] + ] + }, + { + "input": "&bullet", + "description": "Bad named entity: bullet without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&bullet" + ] + ] + }, + { + "input": "•", + "description": "Named entity: bullet; with a semi-colon", + "output": [ + [ + "Character", + "\u2022" + ] + ] + }, + { + "input": "&bump", + "description": "Bad named entity: bump without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&bump" + ] + ] + }, + { + "input": "≎", + "description": "Named entity: bump; with a semi-colon", + "output": [ + [ + "Character", + "\u224e" + ] + ] + }, + { + "input": "&bumpE", + "description": "Bad named entity: bumpE without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&bumpE" + ] + ] + }, + { + "input": "⪮", + "description": "Named entity: bumpE; with a semi-colon", + "output": [ + [ + "Character", + "\u2aae" + ] + ] + }, + { + "input": "&bumpe", + "description": "Bad named entity: bumpe without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&bumpe" + ] + ] + }, + { + "input": "≏", + "description": "Named entity: bumpe; with a semi-colon", + "output": [ + [ + "Character", + "\u224f" + ] + ] + }, + { + "input": "&bumpeq", + "description": "Bad named entity: bumpeq without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&bumpeq" + ] + ] + }, + { + "input": "≏", + "description": "Named entity: bumpeq; with a semi-colon", + "output": [ + [ + "Character", + "\u224f" + ] + ] + }, + { + "input": "&cacute", + "description": "Bad named entity: cacute without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&cacute" + ] + ] + }, + { + "input": "ć", + "description": "Named entity: cacute; with a semi-colon", + "output": [ + [ + "Character", + "\u0107" + ] + ] + }, + { + "input": "&cap", + "description": "Bad named entity: cap without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&cap" + ] + ] + }, + { + "input": "∩", + "description": "Named entity: cap; with a semi-colon", + "output": [ + [ + "Character", + "\u2229" + ] + ] + }, + { + "input": "&capand", + "description": "Bad named entity: capand without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&capand" + ] + ] + }, + { + "input": "⩄", + "description": "Named entity: capand; with a semi-colon", + "output": [ + [ + "Character", + "\u2a44" + ] + ] + }, + { + "input": "&capbrcup", + "description": "Bad named entity: capbrcup without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&capbrcup" + ] + ] + }, + { + "input": "⩉", + "description": "Named entity: capbrcup; with a semi-colon", + "output": [ + [ + "Character", + "\u2a49" + ] + ] + }, + { + "input": "&capcap", + "description": "Bad named entity: capcap without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&capcap" + ] + ] + }, + { + "input": "⩋", + "description": "Named entity: capcap; with a semi-colon", + "output": [ + [ + "Character", + "\u2a4b" + ] + ] + }, + { + "input": "&capcup", + "description": "Bad named entity: capcup without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&capcup" + ] + ] + }, + { + "input": "⩇", + "description": "Named entity: capcup; with a semi-colon", + "output": [ + [ + "Character", + "\u2a47" + ] + ] + }, + { + "input": "&capdot", + "description": "Bad named entity: capdot without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&capdot" + ] + ] + }, + { + "input": "⩀", + "description": "Named entity: capdot; with a semi-colon", + "output": [ + [ + "Character", + "\u2a40" + ] + ] + }, + { + "input": "&caps", + "description": "Bad named entity: caps without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&caps" + ] + ] + }, + { + "input": "∩︀", + "description": "Named entity: caps; with a semi-colon", + "output": [ + [ + "Character", + "\u2229\ufe00" + ] + ] + }, + { + "input": "&caret", + "description": "Bad named entity: caret without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&caret" + ] + ] + }, + { + "input": "⁁", + "description": "Named entity: caret; with a semi-colon", + "output": [ + [ + "Character", + "\u2041" + ] + ] + }, + { + "input": "&caron", + "description": "Bad named entity: caron without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&caron" + ] + ] + }, + { + "input": "ˇ", + "description": "Named entity: caron; with a semi-colon", + "output": [ + [ + "Character", + "\u02c7" + ] + ] + }, + { + "input": "&ccaps", + "description": "Bad named entity: ccaps without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&ccaps" + ] + ] + }, + { + "input": "⩍", + "description": "Named entity: ccaps; with a semi-colon", + "output": [ + [ + "Character", + "\u2a4d" + ] + ] + }, + { + "input": "&ccaron", + "description": "Bad named entity: ccaron without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&ccaron" + ] + ] + }, + { + "input": "č", + "description": "Named entity: ccaron; with a semi-colon", + "output": [ + [ + "Character", + "\u010d" + ] + ] + }, + { + "input": "ç", + "description": "Named entity: ccedil without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "\u00e7" + ] + ] + }, + { + "input": "ç", + "description": "Named entity: ccedil; with a semi-colon", + "output": [ + [ + "Character", + "\u00e7" + ] + ] + }, + { + "input": "&ccirc", + "description": "Bad named entity: ccirc without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&ccirc" + ] + ] + }, + { + "input": "ĉ", + "description": "Named entity: ccirc; with a semi-colon", + "output": [ + [ + "Character", + "\u0109" + ] + ] + }, + { + "input": "&ccups", + "description": "Bad named entity: ccups without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&ccups" + ] + ] + }, + { + "input": "⩌", + "description": "Named entity: ccups; with a semi-colon", + "output": [ + [ + "Character", + "\u2a4c" + ] + ] + }, + { + "input": "&ccupssm", + "description": "Bad named entity: ccupssm without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&ccupssm" + ] + ] + }, + { + "input": "⩐", + "description": "Named entity: ccupssm; with a semi-colon", + "output": [ + [ + "Character", + "\u2a50" + ] + ] + }, + { + "input": "&cdot", + "description": "Bad named entity: cdot without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&cdot" + ] + ] + }, + { + "input": "ċ", + "description": "Named entity: cdot; with a semi-colon", + "output": [ + [ + "Character", + "\u010b" + ] + ] + }, + { + "input": "¸", + "description": "Named entity: cedil without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "\u00b8" + ] + ] + }, + { + "input": "¸", + "description": "Named entity: cedil; with a semi-colon", + "output": [ + [ + "Character", + "\u00b8" + ] + ] + }, + { + "input": "&cemptyv", + "description": "Bad named entity: cemptyv without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&cemptyv" + ] + ] + }, + { + "input": "⦲", + "description": "Named entity: cemptyv; with a semi-colon", + "output": [ + [ + "Character", + "\u29b2" + ] + ] + }, + { + "input": "¢", + "description": "Named entity: cent without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "\u00a2" + ] + ] + }, + { + "input": "¢", + "description": "Named entity: cent; with a semi-colon", + "output": [ + [ + "Character", + "\u00a2" + ] + ] + }, + { + "input": "·", + "description": "Named entity: centerdot; with a semi-colon", + "output": [ + [ + "Character", + "\u00b7" + ] + ] + }, + { + "input": "&cfr", + "description": "Bad named entity: cfr without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&cfr" + ] + ] + }, + { + "input": "𝔠", + "description": "Named entity: cfr; with a semi-colon", + "output": [ + [ + "Character", + "\ud835\udd20" + ] + ] + }, + { + "input": "&chcy", + "description": "Bad named entity: chcy without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&chcy" + ] + ] + }, + { + "input": "ч", + "description": "Named entity: chcy; with a semi-colon", + "output": [ + [ + "Character", + "\u0447" + ] + ] + }, + { + "input": "&check", + "description": "Bad named entity: check without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&check" + ] + ] + }, + { + "input": "✓", + "description": "Named entity: check; with a semi-colon", + "output": [ + [ + "Character", + "\u2713" + ] + ] + }, + { + "input": "&checkmark", + "description": "Bad named entity: checkmark without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&checkmark" + ] + ] + }, + { + "input": "✓", + "description": "Named entity: checkmark; with a semi-colon", + "output": [ + [ + "Character", + "\u2713" + ] + ] + }, + { + "input": "&chi", + "description": "Bad named entity: chi without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&chi" + ] + ] + }, + { + "input": "χ", + "description": "Named entity: chi; with a semi-colon", + "output": [ + [ + "Character", + "\u03c7" + ] + ] + }, + { + "input": "&cir", + "description": "Bad named entity: cir without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&cir" + ] + ] + }, + { + "input": "○", + "description": "Named entity: cir; with a semi-colon", + "output": [ + [ + "Character", + "\u25cb" + ] + ] + }, + { + "input": "&cirE", + "description": "Bad named entity: cirE without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&cirE" + ] + ] + }, + { + "input": "⧃", + "description": "Named entity: cirE; with a semi-colon", + "output": [ + [ + "Character", + "\u29c3" + ] + ] + }, + { + "input": "&circ", + "description": "Bad named entity: circ without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&circ" + ] + ] + }, + { + "input": "ˆ", + "description": "Named entity: circ; with a semi-colon", + "output": [ + [ + "Character", + "\u02c6" + ] + ] + }, + { + "input": "&circeq", + "description": "Bad named entity: circeq without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&circeq" + ] + ] + }, + { + "input": "≗", + "description": "Named entity: circeq; with a semi-colon", + "output": [ + [ + "Character", + "\u2257" + ] + ] + }, + { + "input": "&circlearrowleft", + "description": "Bad named entity: circlearrowleft without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&circlearrowleft" + ] + ] + }, + { + "input": "↺", + "description": "Named entity: circlearrowleft; with a semi-colon", + "output": [ + [ + "Character", + "\u21ba" + ] + ] + }, + { + "input": "&circlearrowright", + "description": "Bad named entity: circlearrowright without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&circlearrowright" + ] + ] + }, + { + "input": "↻", + "description": "Named entity: circlearrowright; with a semi-colon", + "output": [ + [ + "Character", + "\u21bb" + ] + ] + }, + { + "input": "&circledR", + "description": "Bad named entity: circledR without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&circledR" + ] + ] + }, + { + "input": "®", + "description": "Named entity: circledR; with a semi-colon", + "output": [ + [ + "Character", + "\u00ae" + ] + ] + }, + { + "input": "&circledS", + "description": "Bad named entity: circledS without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&circledS" + ] + ] + }, + { + "input": "Ⓢ", + "description": "Named entity: circledS; with a semi-colon", + "output": [ + [ + "Character", + "\u24c8" + ] + ] + }, + { + "input": "&circledast", + "description": "Bad named entity: circledast without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&circledast" + ] + ] + }, + { + "input": "⊛", + "description": "Named entity: circledast; with a semi-colon", + "output": [ + [ + "Character", + "\u229b" + ] + ] + }, + { + "input": "&circledcirc", + "description": "Bad named entity: circledcirc without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&circledcirc" + ] + ] + }, + { + "input": "⊚", + "description": "Named entity: circledcirc; with a semi-colon", + "output": [ + [ + "Character", + "\u229a" + ] + ] + }, + { + "input": "&circleddash", + "description": "Bad named entity: circleddash without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&circleddash" + ] + ] + }, + { + "input": "⊝", + "description": "Named entity: circleddash; with a semi-colon", + "output": [ + [ + "Character", + "\u229d" + ] + ] + }, + { + "input": "&cire", + "description": "Bad named entity: cire without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&cire" + ] + ] + }, + { + "input": "≗", + "description": "Named entity: cire; with a semi-colon", + "output": [ + [ + "Character", + "\u2257" + ] + ] + }, + { + "input": "&cirfnint", + "description": "Bad named entity: cirfnint without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&cirfnint" + ] + ] + }, + { + "input": "⨐", + "description": "Named entity: cirfnint; with a semi-colon", + "output": [ + [ + "Character", + "\u2a10" + ] + ] + }, + { + "input": "&cirmid", + "description": "Bad named entity: cirmid without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&cirmid" + ] + ] + }, + { + "input": "⫯", + "description": "Named entity: cirmid; with a semi-colon", + "output": [ + [ + "Character", + "\u2aef" + ] + ] + }, + { + "input": "&cirscir", + "description": "Bad named entity: cirscir without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&cirscir" + ] + ] + }, + { + "input": "⧂", + "description": "Named entity: cirscir; with a semi-colon", + "output": [ + [ + "Character", + "\u29c2" + ] + ] + }, + { + "input": "&clubs", + "description": "Bad named entity: clubs without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&clubs" + ] + ] + }, + { + "input": "♣", + "description": "Named entity: clubs; with a semi-colon", + "output": [ + [ + "Character", + "\u2663" + ] + ] + }, + { + "input": "&clubsuit", + "description": "Bad named entity: clubsuit without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&clubsuit" + ] + ] + }, + { + "input": "♣", + "description": "Named entity: clubsuit; with a semi-colon", + "output": [ + [ + "Character", + "\u2663" + ] + ] + }, + { + "input": "&colon", + "description": "Bad named entity: colon without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&colon" + ] + ] + }, + { + "input": ":", + "description": "Named entity: colon; with a semi-colon", + "output": [ + [ + "Character", + ":" + ] + ] + }, + { + "input": "&colone", + "description": "Bad named entity: colone without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&colone" + ] + ] + }, + { + "input": "≔", + "description": "Named entity: colone; with a semi-colon", + "output": [ + [ + "Character", + "\u2254" + ] + ] + }, + { + "input": "&coloneq", + "description": "Bad named entity: coloneq without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&coloneq" + ] + ] + }, + { + "input": "≔", + "description": "Named entity: coloneq; with a semi-colon", + "output": [ + [ + "Character", + "\u2254" + ] + ] + }, + { + "input": "&comma", + "description": "Bad named entity: comma without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&comma" + ] + ] + }, + { + "input": ",", + "description": "Named entity: comma; with a semi-colon", + "output": [ + [ + "Character", + "," + ] + ] + }, + { + "input": "&commat", + "description": "Bad named entity: commat without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&commat" + ] + ] + }, + { + "input": "@", + "description": "Named entity: commat; with a semi-colon", + "output": [ + [ + "Character", + "@" + ] + ] + }, + { + "input": "&comp", + "description": "Bad named entity: comp without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&comp" + ] + ] + }, + { + "input": "∁", + "description": "Named entity: comp; with a semi-colon", + "output": [ + [ + "Character", + "\u2201" + ] + ] + }, + { + "input": "&compfn", + "description": "Bad named entity: compfn without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&compfn" + ] + ] + }, + { + "input": "∘", + "description": "Named entity: compfn; with a semi-colon", + "output": [ + [ + "Character", + "\u2218" + ] + ] + }, + { + "input": "&complement", + "description": "Bad named entity: complement without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&complement" + ] + ] + }, + { + "input": "∁", + "description": "Named entity: complement; with a semi-colon", + "output": [ + [ + "Character", + "\u2201" + ] + ] + }, + { + "input": "&complexes", + "description": "Bad named entity: complexes without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&complexes" + ] + ] + }, + { + "input": "ℂ", + "description": "Named entity: complexes; with a semi-colon", + "output": [ + [ + "Character", + "\u2102" + ] + ] + }, + { + "input": "&cong", + "description": "Bad named entity: cong without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&cong" + ] + ] + }, + { + "input": "≅", + "description": "Named entity: cong; with a semi-colon", + "output": [ + [ + "Character", + "\u2245" + ] + ] + }, + { + "input": "&congdot", + "description": "Bad named entity: congdot without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&congdot" + ] + ] + }, + { + "input": "⩭", + "description": "Named entity: congdot; with a semi-colon", + "output": [ + [ + "Character", + "\u2a6d" + ] + ] + }, + { + "input": "&conint", + "description": "Bad named entity: conint without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&conint" + ] + ] + }, + { + "input": "∮", + "description": "Named entity: conint; with a semi-colon", + "output": [ + [ + "Character", + "\u222e" + ] + ] + }, + { + "input": "&copf", + "description": "Bad named entity: copf without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&copf" + ] + ] + }, + { + "input": "𝕔", + "description": "Named entity: copf; with a semi-colon", + "output": [ + [ + "Character", + "\ud835\udd54" + ] + ] + }, + { + "input": "&coprod", + "description": "Bad named entity: coprod without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&coprod" + ] + ] + }, + { + "input": "∐", + "description": "Named entity: coprod; with a semi-colon", + "output": [ + [ + "Character", + "\u2210" + ] + ] + }, + { + "input": "©", + "description": "Named entity: copy without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "\u00a9" + ] + ] + }, + { + "input": "©", + "description": "Named entity: copy; with a semi-colon", + "output": [ + [ + "Character", + "\u00a9" + ] + ] + }, + { + "input": "℗", + "description": "Named entity: copysr; with a semi-colon", + "output": [ + [ + "Character", + "\u2117" + ] + ] + }, + { + "input": "&crarr", + "description": "Bad named entity: crarr without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&crarr" + ] + ] + }, + { + "input": "↵", + "description": "Named entity: crarr; with a semi-colon", + "output": [ + [ + "Character", + "\u21b5" + ] + ] + }, + { + "input": "&cross", + "description": "Bad named entity: cross without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&cross" + ] + ] + }, + { + "input": "✗", + "description": "Named entity: cross; with a semi-colon", + "output": [ + [ + "Character", + "\u2717" + ] + ] + }, + { + "input": "&cscr", + "description": "Bad named entity: cscr without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&cscr" + ] + ] + }, + { + "input": "𝒸", + "description": "Named entity: cscr; with a semi-colon", + "output": [ + [ + "Character", + "\ud835\udcb8" + ] + ] + }, + { + "input": "&csub", + "description": "Bad named entity: csub without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&csub" + ] + ] + }, + { + "input": "⫏", + "description": "Named entity: csub; with a semi-colon", + "output": [ + [ + "Character", + "\u2acf" + ] + ] + }, + { + "input": "&csube", + "description": "Bad named entity: csube without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&csube" + ] + ] + }, + { + "input": "⫑", + "description": "Named entity: csube; with a semi-colon", + "output": [ + [ + "Character", + "\u2ad1" + ] + ] + }, + { + "input": "&csup", + "description": "Bad named entity: csup without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&csup" + ] + ] + }, + { + "input": "⫐", + "description": "Named entity: csup; with a semi-colon", + "output": [ + [ + "Character", + "\u2ad0" + ] + ] + }, + { + "input": "&csupe", + "description": "Bad named entity: csupe without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&csupe" + ] + ] + }, + { + "input": "⫒", + "description": "Named entity: csupe; with a semi-colon", + "output": [ + [ + "Character", + "\u2ad2" + ] + ] + }, + { + "input": "&ctdot", + "description": "Bad named entity: ctdot without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&ctdot" + ] + ] + }, + { + "input": "⋯", + "description": "Named entity: ctdot; with a semi-colon", + "output": [ + [ + "Character", + "\u22ef" + ] + ] + }, + { + "input": "&cudarrl", + "description": "Bad named entity: cudarrl without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&cudarrl" + ] + ] + }, + { + "input": "⤸", + "description": "Named entity: cudarrl; with a semi-colon", + "output": [ + [ + "Character", + "\u2938" + ] + ] + }, + { + "input": "&cudarrr", + "description": "Bad named entity: cudarrr without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&cudarrr" + ] + ] + }, + { + "input": "⤵", + "description": "Named entity: cudarrr; with a semi-colon", + "output": [ + [ + "Character", + "\u2935" + ] + ] + }, + { + "input": "&cuepr", + "description": "Bad named entity: cuepr without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&cuepr" + ] + ] + }, + { + "input": "⋞", + "description": "Named entity: cuepr; with a semi-colon", + "output": [ + [ + "Character", + "\u22de" + ] + ] + }, + { + "input": "&cuesc", + "description": "Bad named entity: cuesc without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&cuesc" + ] + ] + }, + { + "input": "⋟", + "description": "Named entity: cuesc; with a semi-colon", + "output": [ + [ + "Character", + "\u22df" + ] + ] + }, + { + "input": "&cularr", + "description": "Bad named entity: cularr without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&cularr" + ] + ] + }, + { + "input": "↶", + "description": "Named entity: cularr; with a semi-colon", + "output": [ + [ + "Character", + "\u21b6" + ] + ] + }, + { + "input": "&cularrp", + "description": "Bad named entity: cularrp without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&cularrp" + ] + ] + }, + { + "input": "⤽", + "description": "Named entity: cularrp; with a semi-colon", + "output": [ + [ + "Character", + "\u293d" + ] + ] + }, + { + "input": "&cup", + "description": "Bad named entity: cup without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&cup" + ] + ] + }, + { + "input": "∪", + "description": "Named entity: cup; with a semi-colon", + "output": [ + [ + "Character", + "\u222a" + ] + ] + }, + { + "input": "&cupbrcap", + "description": "Bad named entity: cupbrcap without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&cupbrcap" + ] + ] + }, + { + "input": "⩈", + "description": "Named entity: cupbrcap; with a semi-colon", + "output": [ + [ + "Character", + "\u2a48" + ] + ] + }, + { + "input": "&cupcap", + "description": "Bad named entity: cupcap without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&cupcap" + ] + ] + }, + { + "input": "⩆", + "description": "Named entity: cupcap; with a semi-colon", + "output": [ + [ + "Character", + "\u2a46" + ] + ] + }, + { + "input": "&cupcup", + "description": "Bad named entity: cupcup without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&cupcup" + ] + ] + }, + { + "input": "⩊", + "description": "Named entity: cupcup; with a semi-colon", + "output": [ + [ + "Character", + "\u2a4a" + ] + ] + }, + { + "input": "&cupdot", + "description": "Bad named entity: cupdot without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&cupdot" + ] + ] + }, + { + "input": "⊍", + "description": "Named entity: cupdot; with a semi-colon", + "output": [ + [ + "Character", + "\u228d" + ] + ] + }, + { + "input": "&cupor", + "description": "Bad named entity: cupor without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&cupor" + ] + ] + }, + { + "input": "⩅", + "description": "Named entity: cupor; with a semi-colon", + "output": [ + [ + "Character", + "\u2a45" + ] + ] + }, + { + "input": "&cups", + "description": "Bad named entity: cups without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&cups" + ] + ] + }, + { + "input": "∪︀", + "description": "Named entity: cups; with a semi-colon", + "output": [ + [ + "Character", + "\u222a\ufe00" + ] + ] + }, + { + "input": "&curarr", + "description": "Bad named entity: curarr without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&curarr" + ] + ] + }, + { + "input": "↷", + "description": "Named entity: curarr; with a semi-colon", + "output": [ + [ + "Character", + "\u21b7" + ] + ] + }, + { + "input": "&curarrm", + "description": "Bad named entity: curarrm without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&curarrm" + ] + ] + }, + { + "input": "⤼", + "description": "Named entity: curarrm; with a semi-colon", + "output": [ + [ + "Character", + "\u293c" + ] + ] + }, + { + "input": "&curlyeqprec", + "description": "Bad named entity: curlyeqprec without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&curlyeqprec" + ] + ] + }, + { + "input": "⋞", + "description": "Named entity: curlyeqprec; with a semi-colon", + "output": [ + [ + "Character", + "\u22de" + ] + ] + }, + { + "input": "&curlyeqsucc", + "description": "Bad named entity: curlyeqsucc without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&curlyeqsucc" + ] + ] + }, + { + "input": "⋟", + "description": "Named entity: curlyeqsucc; with a semi-colon", + "output": [ + [ + "Character", + "\u22df" + ] + ] + }, + { + "input": "&curlyvee", + "description": "Bad named entity: curlyvee without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&curlyvee" + ] + ] + }, + { + "input": "⋎", + "description": "Named entity: curlyvee; with a semi-colon", + "output": [ + [ + "Character", + "\u22ce" + ] + ] + }, + { + "input": "&curlywedge", + "description": "Bad named entity: curlywedge without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&curlywedge" + ] + ] + }, + { + "input": "⋏", + "description": "Named entity: curlywedge; with a semi-colon", + "output": [ + [ + "Character", + "\u22cf" + ] + ] + }, + { + "input": "¤", + "description": "Named entity: curren without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "\u00a4" + ] + ] + }, + { + "input": "¤", + "description": "Named entity: curren; with a semi-colon", + "output": [ + [ + "Character", + "\u00a4" + ] + ] + }, + { + "input": "&curvearrowleft", + "description": "Bad named entity: curvearrowleft without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&curvearrowleft" + ] + ] + }, + { + "input": "↶", + "description": "Named entity: curvearrowleft; with a semi-colon", + "output": [ + [ + "Character", + "\u21b6" + ] + ] + }, + { + "input": "&curvearrowright", + "description": "Bad named entity: curvearrowright without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&curvearrowright" + ] + ] + }, + { + "input": "↷", + "description": "Named entity: curvearrowright; with a semi-colon", + "output": [ + [ + "Character", + "\u21b7" + ] + ] + }, + { + "input": "&cuvee", + "description": "Bad named entity: cuvee without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&cuvee" + ] + ] + }, + { + "input": "⋎", + "description": "Named entity: cuvee; with a semi-colon", + "output": [ + [ + "Character", + "\u22ce" + ] + ] + }, + { + "input": "&cuwed", + "description": "Bad named entity: cuwed without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&cuwed" + ] + ] + }, + { + "input": "⋏", + "description": "Named entity: cuwed; with a semi-colon", + "output": [ + [ + "Character", + "\u22cf" + ] + ] + }, + { + "input": "&cwconint", + "description": "Bad named entity: cwconint without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&cwconint" + ] + ] + }, + { + "input": "∲", + "description": "Named entity: cwconint; with a semi-colon", + "output": [ + [ + "Character", + "\u2232" + ] + ] + }, + { + "input": "&cwint", + "description": "Bad named entity: cwint without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&cwint" + ] + ] + }, + { + "input": "∱", + "description": "Named entity: cwint; with a semi-colon", + "output": [ + [ + "Character", + "\u2231" + ] + ] + }, + { + "input": "&cylcty", + "description": "Bad named entity: cylcty without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&cylcty" + ] + ] + }, + { + "input": "⌭", + "description": "Named entity: cylcty; with a semi-colon", + "output": [ + [ + "Character", + "\u232d" + ] + ] + }, + { + "input": "&dArr", + "description": "Bad named entity: dArr without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&dArr" + ] + ] + }, + { + "input": "⇓", + "description": "Named entity: dArr; with a semi-colon", + "output": [ + [ + "Character", + "\u21d3" + ] + ] + }, + { + "input": "&dHar", + "description": "Bad named entity: dHar without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&dHar" + ] + ] + }, + { + "input": "⥥", + "description": "Named entity: dHar; with a semi-colon", + "output": [ + [ + "Character", + "\u2965" + ] + ] + }, + { + "input": "&dagger", + "description": "Bad named entity: dagger without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&dagger" + ] + ] + }, + { + "input": "†", + "description": "Named entity: dagger; with a semi-colon", + "output": [ + [ + "Character", + "\u2020" + ] + ] + }, + { + "input": "&daleth", + "description": "Bad named entity: daleth without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&daleth" + ] + ] + }, + { + "input": "ℸ", + "description": "Named entity: daleth; with a semi-colon", + "output": [ + [ + "Character", + "\u2138" + ] + ] + }, + { + "input": "&darr", + "description": "Bad named entity: darr without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&darr" + ] + ] + }, + { + "input": "↓", + "description": "Named entity: darr; with a semi-colon", + "output": [ + [ + "Character", + "\u2193" + ] + ] + }, + { + "input": "&dash", + "description": "Bad named entity: dash without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&dash" + ] + ] + }, + { + "input": "‐", + "description": "Named entity: dash; with a semi-colon", + "output": [ + [ + "Character", + "\u2010" + ] + ] + }, + { + "input": "&dashv", + "description": "Bad named entity: dashv without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&dashv" + ] + ] + }, + { + "input": "⊣", + "description": "Named entity: dashv; with a semi-colon", + "output": [ + [ + "Character", + "\u22a3" + ] + ] + }, + { + "input": "&dbkarow", + "description": "Bad named entity: dbkarow without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&dbkarow" + ] + ] + }, + { + "input": "⤏", + "description": "Named entity: dbkarow; with a semi-colon", + "output": [ + [ + "Character", + "\u290f" + ] + ] + }, + { + "input": "&dblac", + "description": "Bad named entity: dblac without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&dblac" + ] + ] + }, + { + "input": "˝", + "description": "Named entity: dblac; with a semi-colon", + "output": [ + [ + "Character", + "\u02dd" + ] + ] + }, + { + "input": "&dcaron", + "description": "Bad named entity: dcaron without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&dcaron" + ] + ] + }, + { + "input": "ď", + "description": "Named entity: dcaron; with a semi-colon", + "output": [ + [ + "Character", + "\u010f" + ] + ] + }, + { + "input": "&dcy", + "description": "Bad named entity: dcy without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&dcy" + ] + ] + }, + { + "input": "д", + "description": "Named entity: dcy; with a semi-colon", + "output": [ + [ + "Character", + "\u0434" + ] + ] + }, + { + "input": "&dd", + "description": "Bad named entity: dd without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&dd" + ] + ] + }, + { + "input": "ⅆ", + "description": "Named entity: dd; with a semi-colon", + "output": [ + [ + "Character", + "\u2146" + ] + ] + }, + { + "input": "&ddagger", + "description": "Bad named entity: ddagger without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&ddagger" + ] + ] + }, + { + "input": "‡", + "description": "Named entity: ddagger; with a semi-colon", + "output": [ + [ + "Character", + "\u2021" + ] + ] + }, + { + "input": "&ddarr", + "description": "Bad named entity: ddarr without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&ddarr" + ] + ] + }, + { + "input": "⇊", + "description": "Named entity: ddarr; with a semi-colon", + "output": [ + [ + "Character", + "\u21ca" + ] + ] + }, + { + "input": "&ddotseq", + "description": "Bad named entity: ddotseq without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&ddotseq" + ] + ] + }, + { + "input": "⩷", + "description": "Named entity: ddotseq; with a semi-colon", + "output": [ + [ + "Character", + "\u2a77" + ] + ] + }, + { + "input": "°", + "description": "Named entity: deg without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "\u00b0" + ] + ] + }, + { + "input": "°", + "description": "Named entity: deg; with a semi-colon", + "output": [ + [ + "Character", + "\u00b0" + ] + ] + }, + { + "input": "&delta", + "description": "Bad named entity: delta without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&delta" + ] + ] + }, + { + "input": "δ", + "description": "Named entity: delta; with a semi-colon", + "output": [ + [ + "Character", + "\u03b4" + ] + ] + }, + { + "input": "&demptyv", + "description": "Bad named entity: demptyv without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&demptyv" + ] + ] + }, + { + "input": "⦱", + "description": "Named entity: demptyv; with a semi-colon", + "output": [ + [ + "Character", + "\u29b1" + ] + ] + }, + { + "input": "&dfisht", + "description": "Bad named entity: dfisht without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&dfisht" + ] + ] + }, + { + "input": "⥿", + "description": "Named entity: dfisht; with a semi-colon", + "output": [ + [ + "Character", + "\u297f" + ] + ] + }, + { + "input": "&dfr", + "description": "Bad named entity: dfr without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&dfr" + ] + ] + }, + { + "input": "𝔡", + "description": "Named entity: dfr; with a semi-colon", + "output": [ + [ + "Character", + "\ud835\udd21" + ] + ] + }, + { + "input": "&dharl", + "description": "Bad named entity: dharl without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&dharl" + ] + ] + }, + { + "input": "⇃", + "description": "Named entity: dharl; with a semi-colon", + "output": [ + [ + "Character", + "\u21c3" + ] + ] + }, + { + "input": "&dharr", + "description": "Bad named entity: dharr without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&dharr" + ] + ] + }, + { + "input": "⇂", + "description": "Named entity: dharr; with a semi-colon", + "output": [ + [ + "Character", + "\u21c2" + ] + ] + }, + { + "input": "&diam", + "description": "Bad named entity: diam without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&diam" + ] + ] + }, + { + "input": "⋄", + "description": "Named entity: diam; with a semi-colon", + "output": [ + [ + "Character", + "\u22c4" + ] + ] + }, + { + "input": "&diamond", + "description": "Bad named entity: diamond without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&diamond" + ] + ] + }, + { + "input": "⋄", + "description": "Named entity: diamond; with a semi-colon", + "output": [ + [ + "Character", + "\u22c4" + ] + ] + }, + { + "input": "&diamondsuit", + "description": "Bad named entity: diamondsuit without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&diamondsuit" + ] + ] + }, + { + "input": "♦", + "description": "Named entity: diamondsuit; with a semi-colon", + "output": [ + [ + "Character", + "\u2666" + ] + ] + }, + { + "input": "&diams", + "description": "Bad named entity: diams without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&diams" + ] + ] + }, + { + "input": "♦", + "description": "Named entity: diams; with a semi-colon", + "output": [ + [ + "Character", + "\u2666" + ] + ] + }, + { + "input": "&die", + "description": "Bad named entity: die without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&die" + ] + ] + }, + { + "input": "¨", + "description": "Named entity: die; with a semi-colon", + "output": [ + [ + "Character", + "\u00a8" + ] + ] + }, + { + "input": "&digamma", + "description": "Bad named entity: digamma without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&digamma" + ] + ] + }, + { + "input": "ϝ", + "description": "Named entity: digamma; with a semi-colon", + "output": [ + [ + "Character", + "\u03dd" + ] + ] + }, + { + "input": "&disin", + "description": "Bad named entity: disin without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&disin" + ] + ] + }, + { + "input": "⋲", + "description": "Named entity: disin; with a semi-colon", + "output": [ + [ + "Character", + "\u22f2" + ] + ] + }, + { + "input": "&div", + "description": "Bad named entity: div without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&div" + ] + ] + }, + { + "input": "÷", + "description": "Named entity: div; with a semi-colon", + "output": [ + [ + "Character", + "\u00f7" + ] + ] + }, + { + "input": "÷", + "description": "Named entity: divide without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "\u00f7" + ] + ] + }, + { + "input": "÷", + "description": "Named entity: divide; with a semi-colon", + "output": [ + [ + "Character", + "\u00f7" + ] + ] + }, + { + "input": "⋇", + "description": "Named entity: divideontimes; with a semi-colon", + "output": [ + [ + "Character", + "\u22c7" + ] + ] + }, + { + "input": "&divonx", + "description": "Bad named entity: divonx without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&divonx" + ] + ] + }, + { + "input": "⋇", + "description": "Named entity: divonx; with a semi-colon", + "output": [ + [ + "Character", + "\u22c7" + ] + ] + }, + { + "input": "&djcy", + "description": "Bad named entity: djcy without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&djcy" + ] + ] + }, + { + "input": "ђ", + "description": "Named entity: djcy; with a semi-colon", + "output": [ + [ + "Character", + "\u0452" + ] + ] + }, + { + "input": "&dlcorn", + "description": "Bad named entity: dlcorn without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&dlcorn" + ] + ] + }, + { + "input": "⌞", + "description": "Named entity: dlcorn; with a semi-colon", + "output": [ + [ + "Character", + "\u231e" + ] + ] + }, + { + "input": "&dlcrop", + "description": "Bad named entity: dlcrop without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&dlcrop" + ] + ] + }, + { + "input": "⌍", + "description": "Named entity: dlcrop; with a semi-colon", + "output": [ + [ + "Character", + "\u230d" + ] + ] + }, + { + "input": "&dollar", + "description": "Bad named entity: dollar without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&dollar" + ] + ] + }, + { + "input": "$", + "description": "Named entity: dollar; with a semi-colon", + "output": [ + [ + "Character", + "$" + ] + ] + }, + { + "input": "&dopf", + "description": "Bad named entity: dopf without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&dopf" + ] + ] + }, + { + "input": "𝕕", + "description": "Named entity: dopf; with a semi-colon", + "output": [ + [ + "Character", + "\ud835\udd55" + ] + ] + }, + { + "input": "&dot", + "description": "Bad named entity: dot without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&dot" + ] + ] + }, + { + "input": "˙", + "description": "Named entity: dot; with a semi-colon", + "output": [ + [ + "Character", + "\u02d9" + ] + ] + }, + { + "input": "&doteq", + "description": "Bad named entity: doteq without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&doteq" + ] + ] + }, + { + "input": "≐", + "description": "Named entity: doteq; with a semi-colon", + "output": [ + [ + "Character", + "\u2250" + ] + ] + }, + { + "input": "&doteqdot", + "description": "Bad named entity: doteqdot without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&doteqdot" + ] + ] + }, + { + "input": "≑", + "description": "Named entity: doteqdot; with a semi-colon", + "output": [ + [ + "Character", + "\u2251" + ] + ] + }, + { + "input": "&dotminus", + "description": "Bad named entity: dotminus without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&dotminus" + ] + ] + }, + { + "input": "∸", + "description": "Named entity: dotminus; with a semi-colon", + "output": [ + [ + "Character", + "\u2238" + ] + ] + }, + { + "input": "&dotplus", + "description": "Bad named entity: dotplus without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&dotplus" + ] + ] + }, + { + "input": "∔", + "description": "Named entity: dotplus; with a semi-colon", + "output": [ + [ + "Character", + "\u2214" + ] + ] + }, + { + "input": "&dotsquare", + "description": "Bad named entity: dotsquare without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&dotsquare" + ] + ] + }, + { + "input": "⊡", + "description": "Named entity: dotsquare; with a semi-colon", + "output": [ + [ + "Character", + "\u22a1" + ] + ] + }, + { + "input": "&doublebarwedge", + "description": "Bad named entity: doublebarwedge without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&doublebarwedge" + ] + ] + }, + { + "input": "⌆", + "description": "Named entity: doublebarwedge; with a semi-colon", + "output": [ + [ + "Character", + "\u2306" + ] + ] + }, + { + "input": "&downarrow", + "description": "Bad named entity: downarrow without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&downarrow" + ] + ] + }, + { + "input": "↓", + "description": "Named entity: downarrow; with a semi-colon", + "output": [ + [ + "Character", + "\u2193" + ] + ] + }, + { + "input": "&downdownarrows", + "description": "Bad named entity: downdownarrows without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&downdownarrows" + ] + ] + }, + { + "input": "⇊", + "description": "Named entity: downdownarrows; with a semi-colon", + "output": [ + [ + "Character", + "\u21ca" + ] + ] + }, + { + "input": "&downharpoonleft", + "description": "Bad named entity: downharpoonleft without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&downharpoonleft" + ] + ] + }, + { + "input": "⇃", + "description": "Named entity: downharpoonleft; with a semi-colon", + "output": [ + [ + "Character", + "\u21c3" + ] + ] + }, + { + "input": "&downharpoonright", + "description": "Bad named entity: downharpoonright without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&downharpoonright" + ] + ] + }, + { + "input": "⇂", + "description": "Named entity: downharpoonright; with a semi-colon", + "output": [ + [ + "Character", + "\u21c2" + ] + ] + }, + { + "input": "&drbkarow", + "description": "Bad named entity: drbkarow without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&drbkarow" + ] + ] + }, + { + "input": "⤐", + "description": "Named entity: drbkarow; with a semi-colon", + "output": [ + [ + "Character", + "\u2910" + ] + ] + }, + { + "input": "&drcorn", + "description": "Bad named entity: drcorn without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&drcorn" + ] + ] + }, + { + "input": "⌟", + "description": "Named entity: drcorn; with a semi-colon", + "output": [ + [ + "Character", + "\u231f" + ] + ] + }, + { + "input": "&drcrop", + "description": "Bad named entity: drcrop without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&drcrop" + ] + ] + }, + { + "input": "⌌", + "description": "Named entity: drcrop; with a semi-colon", + "output": [ + [ + "Character", + "\u230c" + ] + ] + }, + { + "input": "&dscr", + "description": "Bad named entity: dscr without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&dscr" + ] + ] + }, + { + "input": "𝒹", + "description": "Named entity: dscr; with a semi-colon", + "output": [ + [ + "Character", + "\ud835\udcb9" + ] + ] + }, + { + "input": "&dscy", + "description": "Bad named entity: dscy without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&dscy" + ] + ] + }, + { + "input": "ѕ", + "description": "Named entity: dscy; with a semi-colon", + "output": [ + [ + "Character", + "\u0455" + ] + ] + }, + { + "input": "&dsol", + "description": "Bad named entity: dsol without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&dsol" + ] + ] + }, + { + "input": "⧶", + "description": "Named entity: dsol; with a semi-colon", + "output": [ + [ + "Character", + "\u29f6" + ] + ] + }, + { + "input": "&dstrok", + "description": "Bad named entity: dstrok without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&dstrok" + ] + ] + }, + { + "input": "đ", + "description": "Named entity: dstrok; with a semi-colon", + "output": [ + [ + "Character", + "\u0111" + ] + ] + }, + { + "input": "&dtdot", + "description": "Bad named entity: dtdot without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&dtdot" + ] + ] + }, + { + "input": "⋱", + "description": "Named entity: dtdot; with a semi-colon", + "output": [ + [ + "Character", + "\u22f1" + ] + ] + }, + { + "input": "&dtri", + "description": "Bad named entity: dtri without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&dtri" + ] + ] + }, + { + "input": "▿", + "description": "Named entity: dtri; with a semi-colon", + "output": [ + [ + "Character", + "\u25bf" + ] + ] + }, + { + "input": "&dtrif", + "description": "Bad named entity: dtrif without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&dtrif" + ] + ] + }, + { + "input": "▾", + "description": "Named entity: dtrif; with a semi-colon", + "output": [ + [ + "Character", + "\u25be" + ] + ] + }, + { + "input": "&duarr", + "description": "Bad named entity: duarr without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&duarr" + ] + ] + }, + { + "input": "⇵", + "description": "Named entity: duarr; with a semi-colon", + "output": [ + [ + "Character", + "\u21f5" + ] + ] + }, + { + "input": "&duhar", + "description": "Bad named entity: duhar without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&duhar" + ] + ] + }, + { + "input": "⥯", + "description": "Named entity: duhar; with a semi-colon", + "output": [ + [ + "Character", + "\u296f" + ] + ] + }, + { + "input": "&dwangle", + "description": "Bad named entity: dwangle without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&dwangle" + ] + ] + }, + { + "input": "⦦", + "description": "Named entity: dwangle; with a semi-colon", + "output": [ + [ + "Character", + "\u29a6" + ] + ] + }, + { + "input": "&dzcy", + "description": "Bad named entity: dzcy without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&dzcy" + ] + ] + }, + { + "input": "џ", + "description": "Named entity: dzcy; with a semi-colon", + "output": [ + [ + "Character", + "\u045f" + ] + ] + }, + { + "input": "&dzigrarr", + "description": "Bad named entity: dzigrarr without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&dzigrarr" + ] + ] + }, + { + "input": "⟿", + "description": "Named entity: dzigrarr; with a semi-colon", + "output": [ + [ + "Character", + "\u27ff" + ] + ] + }, + { + "input": "&eDDot", + "description": "Bad named entity: eDDot without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&eDDot" + ] + ] + }, + { + "input": "⩷", + "description": "Named entity: eDDot; with a semi-colon", + "output": [ + [ + "Character", + "\u2a77" + ] + ] + }, + { + "input": "&eDot", + "description": "Bad named entity: eDot without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&eDot" + ] + ] + }, + { + "input": "≑", + "description": "Named entity: eDot; with a semi-colon", + "output": [ + [ + "Character", + "\u2251" + ] + ] + }, + { + "input": "é", + "description": "Named entity: eacute without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "\u00e9" + ] + ] + }, + { + "input": "é", + "description": "Named entity: eacute; with a semi-colon", + "output": [ + [ + "Character", + "\u00e9" + ] + ] + }, + { + "input": "&easter", + "description": "Bad named entity: easter without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&easter" + ] + ] + }, + { + "input": "⩮", + "description": "Named entity: easter; with a semi-colon", + "output": [ + [ + "Character", + "\u2a6e" + ] + ] + }, + { + "input": "&ecaron", + "description": "Bad named entity: ecaron without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&ecaron" + ] + ] + }, + { + "input": "ě", + "description": "Named entity: ecaron; with a semi-colon", + "output": [ + [ + "Character", + "\u011b" + ] + ] + }, + { + "input": "&ecir", + "description": "Bad named entity: ecir without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&ecir" + ] + ] + }, + { + "input": "≖", + "description": "Named entity: ecir; with a semi-colon", + "output": [ + [ + "Character", + "\u2256" + ] + ] + }, + { + "input": "ê", + "description": "Named entity: ecirc without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "\u00ea" + ] + ] + }, + { + "input": "ê", + "description": "Named entity: ecirc; with a semi-colon", + "output": [ + [ + "Character", + "\u00ea" + ] + ] + }, + { + "input": "&ecolon", + "description": "Bad named entity: ecolon without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&ecolon" + ] + ] + }, + { + "input": "≕", + "description": "Named entity: ecolon; with a semi-colon", + "output": [ + [ + "Character", + "\u2255" + ] + ] + }, + { + "input": "&ecy", + "description": "Bad named entity: ecy without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&ecy" + ] + ] + }, + { + "input": "э", + "description": "Named entity: ecy; with a semi-colon", + "output": [ + [ + "Character", + "\u044d" + ] + ] + }, + { + "input": "&edot", + "description": "Bad named entity: edot without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&edot" + ] + ] + }, + { + "input": "ė", + "description": "Named entity: edot; with a semi-colon", + "output": [ + [ + "Character", + "\u0117" + ] + ] + }, + { + "input": "&ee", + "description": "Bad named entity: ee without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&ee" + ] + ] + }, + { + "input": "ⅇ", + "description": "Named entity: ee; with a semi-colon", + "output": [ + [ + "Character", + "\u2147" + ] + ] + }, + { + "input": "&efDot", + "description": "Bad named entity: efDot without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&efDot" + ] + ] + }, + { + "input": "≒", + "description": "Named entity: efDot; with a semi-colon", + "output": [ + [ + "Character", + "\u2252" + ] + ] + }, + { + "input": "&efr", + "description": "Bad named entity: efr without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&efr" + ] + ] + }, + { + "input": "𝔢", + "description": "Named entity: efr; with a semi-colon", + "output": [ + [ + "Character", + "\ud835\udd22" + ] + ] + }, + { + "input": "&eg", + "description": "Bad named entity: eg without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&eg" + ] + ] + }, + { + "input": "⪚", + "description": "Named entity: eg; with a semi-colon", + "output": [ + [ + "Character", + "\u2a9a" + ] + ] + }, + { + "input": "è", + "description": "Named entity: egrave without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "\u00e8" + ] + ] + }, + { + "input": "è", + "description": "Named entity: egrave; with a semi-colon", + "output": [ + [ + "Character", + "\u00e8" + ] + ] + }, + { + "input": "&egs", + "description": "Bad named entity: egs without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&egs" + ] + ] + }, + { + "input": "⪖", + "description": "Named entity: egs; with a semi-colon", + "output": [ + [ + "Character", + "\u2a96" + ] + ] + }, + { + "input": "&egsdot", + "description": "Bad named entity: egsdot without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&egsdot" + ] + ] + }, + { + "input": "⪘", + "description": "Named entity: egsdot; with a semi-colon", + "output": [ + [ + "Character", + "\u2a98" + ] + ] + }, + { + "input": "&el", + "description": "Bad named entity: el without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&el" + ] + ] + }, + { + "input": "⪙", + "description": "Named entity: el; with a semi-colon", + "output": [ + [ + "Character", + "\u2a99" + ] + ] + }, + { + "input": "&elinters", + "description": "Bad named entity: elinters without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&elinters" + ] + ] + }, + { + "input": "⏧", + "description": "Named entity: elinters; with a semi-colon", + "output": [ + [ + "Character", + "\u23e7" + ] + ] + }, + { + "input": "&ell", + "description": "Bad named entity: ell without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&ell" + ] + ] + }, + { + "input": "ℓ", + "description": "Named entity: ell; with a semi-colon", + "output": [ + [ + "Character", + "\u2113" + ] + ] + }, + { + "input": "&els", + "description": "Bad named entity: els without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&els" + ] + ] + }, + { + "input": "⪕", + "description": "Named entity: els; with a semi-colon", + "output": [ + [ + "Character", + "\u2a95" + ] + ] + }, + { + "input": "&elsdot", + "description": "Bad named entity: elsdot without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&elsdot" + ] + ] + }, + { + "input": "⪗", + "description": "Named entity: elsdot; with a semi-colon", + "output": [ + [ + "Character", + "\u2a97" + ] + ] + }, + { + "input": "&emacr", + "description": "Bad named entity: emacr without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&emacr" + ] + ] + }, + { + "input": "ē", + "description": "Named entity: emacr; with a semi-colon", + "output": [ + [ + "Character", + "\u0113" + ] + ] + }, + { + "input": "&empty", + "description": "Bad named entity: empty without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&empty" + ] + ] + }, + { + "input": "∅", + "description": "Named entity: empty; with a semi-colon", + "output": [ + [ + "Character", + "\u2205" + ] + ] + }, + { + "input": "&emptyset", + "description": "Bad named entity: emptyset without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&emptyset" + ] + ] + }, + { + "input": "∅", + "description": "Named entity: emptyset; with a semi-colon", + "output": [ + [ + "Character", + "\u2205" + ] + ] + }, + { + "input": "&emptyv", + "description": "Bad named entity: emptyv without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&emptyv" + ] + ] + }, + { + "input": "∅", + "description": "Named entity: emptyv; with a semi-colon", + "output": [ + [ + "Character", + "\u2205" + ] + ] + }, + { + "input": "&emsp", + "description": "Bad named entity: emsp without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&emsp" + ] + ] + }, + { + "input": "&emsp13", + "description": "Bad named entity: emsp13 without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&emsp13" + ] + ] + }, + { + "input": " ", + "description": "Named entity: emsp13; with a semi-colon", + "output": [ + [ + "Character", + "\u2004" + ] + ] + }, + { + "input": "&emsp14", + "description": "Bad named entity: emsp14 without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&emsp14" + ] + ] + }, + { + "input": " ", + "description": "Named entity: emsp14; with a semi-colon", + "output": [ + [ + "Character", + "\u2005" + ] + ] + }, + { + "input": " ", + "description": "Named entity: emsp; with a semi-colon", + "output": [ + [ + "Character", + "\u2003" + ] + ] + }, + { + "input": "&eng", + "description": "Bad named entity: eng without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&eng" + ] + ] + }, + { + "input": "ŋ", + "description": "Named entity: eng; with a semi-colon", + "output": [ + [ + "Character", + "\u014b" + ] + ] + }, + { + "input": "&ensp", + "description": "Bad named entity: ensp without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&ensp" + ] + ] + }, + { + "input": " ", + "description": "Named entity: ensp; with a semi-colon", + "output": [ + [ + "Character", + "\u2002" + ] + ] + }, + { + "input": "&eogon", + "description": "Bad named entity: eogon without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&eogon" + ] + ] + }, + { + "input": "ę", + "description": "Named entity: eogon; with a semi-colon", + "output": [ + [ + "Character", + "\u0119" + ] + ] + }, + { + "input": "&eopf", + "description": "Bad named entity: eopf without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&eopf" + ] + ] + }, + { + "input": "𝕖", + "description": "Named entity: eopf; with a semi-colon", + "output": [ + [ + "Character", + "\ud835\udd56" + ] + ] + }, + { + "input": "&epar", + "description": "Bad named entity: epar without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&epar" + ] + ] + }, + { + "input": "⋕", + "description": "Named entity: epar; with a semi-colon", + "output": [ + [ + "Character", + "\u22d5" + ] + ] + }, + { + "input": "&eparsl", + "description": "Bad named entity: eparsl without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&eparsl" + ] + ] + }, + { + "input": "⧣", + "description": "Named entity: eparsl; with a semi-colon", + "output": [ + [ + "Character", + "\u29e3" + ] + ] + }, + { + "input": "&eplus", + "description": "Bad named entity: eplus without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&eplus" + ] + ] + }, + { + "input": "⩱", + "description": "Named entity: eplus; with a semi-colon", + "output": [ + [ + "Character", + "\u2a71" + ] + ] + }, + { + "input": "&epsi", + "description": "Bad named entity: epsi without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&epsi" + ] + ] + }, + { + "input": "ε", + "description": "Named entity: epsi; with a semi-colon", + "output": [ + [ + "Character", + "\u03b5" + ] + ] + }, + { + "input": "&epsilon", + "description": "Bad named entity: epsilon without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&epsilon" + ] + ] + }, + { + "input": "ε", + "description": "Named entity: epsilon; with a semi-colon", + "output": [ + [ + "Character", + "\u03b5" + ] + ] + }, + { + "input": "&epsiv", + "description": "Bad named entity: epsiv without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&epsiv" + ] + ] + }, + { + "input": "ϵ", + "description": "Named entity: epsiv; with a semi-colon", + "output": [ + [ + "Character", + "\u03f5" + ] + ] + }, + { + "input": "&eqcirc", + "description": "Bad named entity: eqcirc without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&eqcirc" + ] + ] + }, + { + "input": "≖", + "description": "Named entity: eqcirc; with a semi-colon", + "output": [ + [ + "Character", + "\u2256" + ] + ] + }, + { + "input": "&eqcolon", + "description": "Bad named entity: eqcolon without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&eqcolon" + ] + ] + }, + { + "input": "≕", + "description": "Named entity: eqcolon; with a semi-colon", + "output": [ + [ + "Character", + "\u2255" + ] + ] + }, + { + "input": "&eqsim", + "description": "Bad named entity: eqsim without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&eqsim" + ] + ] + }, + { + "input": "≂", + "description": "Named entity: eqsim; with a semi-colon", + "output": [ + [ + "Character", + "\u2242" + ] + ] + }, + { + "input": "&eqslantgtr", + "description": "Bad named entity: eqslantgtr without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&eqslantgtr" + ] + ] + }, + { + "input": "⪖", + "description": "Named entity: eqslantgtr; with a semi-colon", + "output": [ + [ + "Character", + "\u2a96" + ] + ] + }, + { + "input": "&eqslantless", + "description": "Bad named entity: eqslantless without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&eqslantless" + ] + ] + }, + { + "input": "⪕", + "description": "Named entity: eqslantless; with a semi-colon", + "output": [ + [ + "Character", + "\u2a95" + ] + ] + }, + { + "input": "&equals", + "description": "Bad named entity: equals without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&equals" + ] + ] + }, + { + "input": "=", + "description": "Named entity: equals; with a semi-colon", + "output": [ + [ + "Character", + "=" + ] + ] + }, + { + "input": "&equest", + "description": "Bad named entity: equest without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&equest" + ] + ] + }, + { + "input": "≟", + "description": "Named entity: equest; with a semi-colon", + "output": [ + [ + "Character", + "\u225f" + ] + ] + }, + { + "input": "&equiv", + "description": "Bad named entity: equiv without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&equiv" + ] + ] + }, + { + "input": "≡", + "description": "Named entity: equiv; with a semi-colon", + "output": [ + [ + "Character", + "\u2261" + ] + ] + }, + { + "input": "&equivDD", + "description": "Bad named entity: equivDD without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&equivDD" + ] + ] + }, + { + "input": "⩸", + "description": "Named entity: equivDD; with a semi-colon", + "output": [ + [ + "Character", + "\u2a78" + ] + ] + }, + { + "input": "&eqvparsl", + "description": "Bad named entity: eqvparsl without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&eqvparsl" + ] + ] + }, + { + "input": "⧥", + "description": "Named entity: eqvparsl; with a semi-colon", + "output": [ + [ + "Character", + "\u29e5" + ] + ] + }, + { + "input": "&erDot", + "description": "Bad named entity: erDot without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&erDot" + ] + ] + }, + { + "input": "≓", + "description": "Named entity: erDot; with a semi-colon", + "output": [ + [ + "Character", + "\u2253" + ] + ] + }, + { + "input": "&erarr", + "description": "Bad named entity: erarr without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&erarr" + ] + ] + }, + { + "input": "⥱", + "description": "Named entity: erarr; with a semi-colon", + "output": [ + [ + "Character", + "\u2971" + ] + ] + }, + { + "input": "&escr", + "description": "Bad named entity: escr without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&escr" + ] + ] + }, + { + "input": "ℯ", + "description": "Named entity: escr; with a semi-colon", + "output": [ + [ + "Character", + "\u212f" + ] + ] + }, + { + "input": "&esdot", + "description": "Bad named entity: esdot without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&esdot" + ] + ] + }, + { + "input": "≐", + "description": "Named entity: esdot; with a semi-colon", + "output": [ + [ + "Character", + "\u2250" + ] + ] + }, + { + "input": "&esim", + "description": "Bad named entity: esim without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&esim" + ] + ] + }, + { + "input": "≂", + "description": "Named entity: esim; with a semi-colon", + "output": [ + [ + "Character", + "\u2242" + ] + ] + }, + { + "input": "&eta", + "description": "Bad named entity: eta without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&eta" + ] + ] + }, + { + "input": "η", + "description": "Named entity: eta; with a semi-colon", + "output": [ + [ + "Character", + "\u03b7" + ] + ] + }, + { + "input": "ð", + "description": "Named entity: eth without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "\u00f0" + ] + ] + }, + { + "input": "ð", + "description": "Named entity: eth; with a semi-colon", + "output": [ + [ + "Character", + "\u00f0" + ] + ] + }, + { + "input": "ë", + "description": "Named entity: euml without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "\u00eb" + ] + ] + }, + { + "input": "ë", + "description": "Named entity: euml; with a semi-colon", + "output": [ + [ + "Character", + "\u00eb" + ] + ] + }, + { + "input": "&euro", + "description": "Bad named entity: euro without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&euro" + ] + ] + }, + { + "input": "€", + "description": "Named entity: euro; with a semi-colon", + "output": [ + [ + "Character", + "\u20ac" + ] + ] + }, + { + "input": "&excl", + "description": "Bad named entity: excl without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&excl" + ] + ] + }, + { + "input": "!", + "description": "Named entity: excl; with a semi-colon", + "output": [ + [ + "Character", + "!" + ] + ] + }, + { + "input": "&exist", + "description": "Bad named entity: exist without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&exist" + ] + ] + }, + { + "input": "∃", + "description": "Named entity: exist; with a semi-colon", + "output": [ + [ + "Character", + "\u2203" + ] + ] + }, + { + "input": "&expectation", + "description": "Bad named entity: expectation without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&expectation" + ] + ] + }, + { + "input": "ℰ", + "description": "Named entity: expectation; with a semi-colon", + "output": [ + [ + "Character", + "\u2130" + ] + ] + }, + { + "input": "&exponentiale", + "description": "Bad named entity: exponentiale without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&exponentiale" + ] + ] + }, + { + "input": "ⅇ", + "description": "Named entity: exponentiale; with a semi-colon", + "output": [ + [ + "Character", + "\u2147" + ] + ] + }, + { + "input": "&fallingdotseq", + "description": "Bad named entity: fallingdotseq without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&fallingdotseq" + ] + ] + }, + { + "input": "≒", + "description": "Named entity: fallingdotseq; with a semi-colon", + "output": [ + [ + "Character", + "\u2252" + ] + ] + }, + { + "input": "&fcy", + "description": "Bad named entity: fcy without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&fcy" + ] + ] + }, + { + "input": "ф", + "description": "Named entity: fcy; with a semi-colon", + "output": [ + [ + "Character", + "\u0444" + ] + ] + }, + { + "input": "&female", + "description": "Bad named entity: female without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&female" + ] + ] + }, + { + "input": "♀", + "description": "Named entity: female; with a semi-colon", + "output": [ + [ + "Character", + "\u2640" + ] + ] + }, + { + "input": "&ffilig", + "description": "Bad named entity: ffilig without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&ffilig" + ] + ] + }, + { + "input": "ffi", + "description": "Named entity: ffilig; with a semi-colon", + "output": [ + [ + "Character", + "\ufb03" + ] + ] + }, + { + "input": "&fflig", + "description": "Bad named entity: fflig without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&fflig" + ] + ] + }, + { + "input": "ff", + "description": "Named entity: fflig; with a semi-colon", + "output": [ + [ + "Character", + "\ufb00" + ] + ] + }, + { + "input": "&ffllig", + "description": "Bad named entity: ffllig without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&ffllig" + ] + ] + }, + { + "input": "ffl", + "description": "Named entity: ffllig; with a semi-colon", + "output": [ + [ + "Character", + "\ufb04" + ] + ] + }, + { + "input": "&ffr", + "description": "Bad named entity: ffr without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&ffr" + ] + ] + }, + { + "input": "𝔣", + "description": "Named entity: ffr; with a semi-colon", + "output": [ + [ + "Character", + "\ud835\udd23" + ] + ] + }, + { + "input": "&filig", + "description": "Bad named entity: filig without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&filig" + ] + ] + }, + { + "input": "fi", + "description": "Named entity: filig; with a semi-colon", + "output": [ + [ + "Character", + "\ufb01" + ] + ] + }, + { + "input": "&fjlig", + "description": "Bad named entity: fjlig without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&fjlig" + ] + ] + }, + { + "input": "fj", + "description": "Named entity: fjlig; with a semi-colon", + "output": [ + [ + "Character", + "fj" + ] + ] + }, + { + "input": "&flat", + "description": "Bad named entity: flat without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&flat" + ] + ] + }, + { + "input": "♭", + "description": "Named entity: flat; with a semi-colon", + "output": [ + [ + "Character", + "\u266d" + ] + ] + }, + { + "input": "&fllig", + "description": "Bad named entity: fllig without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&fllig" + ] + ] + }, + { + "input": "fl", + "description": "Named entity: fllig; with a semi-colon", + "output": [ + [ + "Character", + "\ufb02" + ] + ] + }, + { + "input": "&fltns", + "description": "Bad named entity: fltns without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&fltns" + ] + ] + }, + { + "input": "▱", + "description": "Named entity: fltns; with a semi-colon", + "output": [ + [ + "Character", + "\u25b1" + ] + ] + }, + { + "input": "&fnof", + "description": "Bad named entity: fnof without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&fnof" + ] + ] + }, + { + "input": "ƒ", + "description": "Named entity: fnof; with a semi-colon", + "output": [ + [ + "Character", + "\u0192" + ] + ] + }, + { + "input": "&fopf", + "description": "Bad named entity: fopf without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&fopf" + ] + ] + }, + { + "input": "𝕗", + "description": "Named entity: fopf; with a semi-colon", + "output": [ + [ + "Character", + "\ud835\udd57" + ] + ] + }, + { + "input": "&forall", + "description": "Bad named entity: forall without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&forall" + ] + ] + }, + { + "input": "∀", + "description": "Named entity: forall; with a semi-colon", + "output": [ + [ + "Character", + "\u2200" + ] + ] + }, + { + "input": "&fork", + "description": "Bad named entity: fork without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&fork" + ] + ] + }, + { + "input": "⋔", + "description": "Named entity: fork; with a semi-colon", + "output": [ + [ + "Character", + "\u22d4" + ] + ] + }, + { + "input": "&forkv", + "description": "Bad named entity: forkv without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&forkv" + ] + ] + }, + { + "input": "⫙", + "description": "Named entity: forkv; with a semi-colon", + "output": [ + [ + "Character", + "\u2ad9" + ] + ] + }, + { + "input": "&fpartint", + "description": "Bad named entity: fpartint without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&fpartint" + ] + ] + }, + { + "input": "⨍", + "description": "Named entity: fpartint; with a semi-colon", + "output": [ + [ + "Character", + "\u2a0d" + ] + ] + }, + { + "input": "½", + "description": "Named entity: frac12 without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "\u00bd" + ] + ] + }, + { + "input": "½", + "description": "Named entity: frac12; with a semi-colon", + "output": [ + [ + "Character", + "\u00bd" + ] + ] + }, + { + "input": "&frac13", + "description": "Bad named entity: frac13 without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&frac13" + ] + ] + }, + { + "input": "⅓", + "description": "Named entity: frac13; with a semi-colon", + "output": [ + [ + "Character", + "\u2153" + ] + ] + }, + { + "input": "¼", + "description": "Named entity: frac14 without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "\u00bc" + ] + ] + }, + { + "input": "¼", + "description": "Named entity: frac14; with a semi-colon", + "output": [ + [ + "Character", + "\u00bc" + ] + ] + }, + { + "input": "&frac15", + "description": "Bad named entity: frac15 without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&frac15" + ] + ] + }, + { + "input": "⅕", + "description": "Named entity: frac15; with a semi-colon", + "output": [ + [ + "Character", + "\u2155" + ] + ] + }, + { + "input": "&frac16", + "description": "Bad named entity: frac16 without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&frac16" + ] + ] + }, + { + "input": "⅙", + "description": "Named entity: frac16; with a semi-colon", + "output": [ + [ + "Character", + "\u2159" + ] + ] + }, + { + "input": "&frac18", + "description": "Bad named entity: frac18 without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&frac18" + ] + ] + }, + { + "input": "⅛", + "description": "Named entity: frac18; with a semi-colon", + "output": [ + [ + "Character", + "\u215b" + ] + ] + }, + { + "input": "&frac23", + "description": "Bad named entity: frac23 without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&frac23" + ] + ] + }, + { + "input": "⅔", + "description": "Named entity: frac23; with a semi-colon", + "output": [ + [ + "Character", + "\u2154" + ] + ] + }, + { + "input": "&frac25", + "description": "Bad named entity: frac25 without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&frac25" + ] + ] + }, + { + "input": "⅖", + "description": "Named entity: frac25; with a semi-colon", + "output": [ + [ + "Character", + "\u2156" + ] + ] + }, + { + "input": "¾", + "description": "Named entity: frac34 without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "\u00be" + ] + ] + }, + { + "input": "¾", + "description": "Named entity: frac34; with a semi-colon", + "output": [ + [ + "Character", + "\u00be" + ] + ] + }, + { + "input": "&frac35", + "description": "Bad named entity: frac35 without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&frac35" + ] + ] + }, + { + "input": "⅗", + "description": "Named entity: frac35; with a semi-colon", + "output": [ + [ + "Character", + "\u2157" + ] + ] + }, + { + "input": "&frac38", + "description": "Bad named entity: frac38 without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&frac38" + ] + ] + }, + { + "input": "⅜", + "description": "Named entity: frac38; with a semi-colon", + "output": [ + [ + "Character", + "\u215c" + ] + ] + }, + { + "input": "&frac45", + "description": "Bad named entity: frac45 without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&frac45" + ] + ] + }, + { + "input": "⅘", + "description": "Named entity: frac45; with a semi-colon", + "output": [ + [ + "Character", + "\u2158" + ] + ] + }, + { + "input": "&frac56", + "description": "Bad named entity: frac56 without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&frac56" + ] + ] + }, + { + "input": "⅚", + "description": "Named entity: frac56; with a semi-colon", + "output": [ + [ + "Character", + "\u215a" + ] + ] + }, + { + "input": "&frac58", + "description": "Bad named entity: frac58 without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&frac58" + ] + ] + }, + { + "input": "⅝", + "description": "Named entity: frac58; with a semi-colon", + "output": [ + [ + "Character", + "\u215d" + ] + ] + }, + { + "input": "&frac78", + "description": "Bad named entity: frac78 without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&frac78" + ] + ] + }, + { + "input": "⅞", + "description": "Named entity: frac78; with a semi-colon", + "output": [ + [ + "Character", + "\u215e" + ] + ] + }, + { + "input": "&frasl", + "description": "Bad named entity: frasl without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&frasl" + ] + ] + }, + { + "input": "⁄", + "description": "Named entity: frasl; with a semi-colon", + "output": [ + [ + "Character", + "\u2044" + ] + ] + }, + { + "input": "&frown", + "description": "Bad named entity: frown without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&frown" + ] + ] + }, + { + "input": "⌢", + "description": "Named entity: frown; with a semi-colon", + "output": [ + [ + "Character", + "\u2322" + ] + ] + }, + { + "input": "&fscr", + "description": "Bad named entity: fscr without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&fscr" + ] + ] + }, + { + "input": "𝒻", + "description": "Named entity: fscr; with a semi-colon", + "output": [ + [ + "Character", + "\ud835\udcbb" + ] + ] + }, + { + "input": "&gE", + "description": "Bad named entity: gE without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&gE" + ] + ] + }, + { + "input": "≧", + "description": "Named entity: gE; with a semi-colon", + "output": [ + [ + "Character", + "\u2267" + ] + ] + }, + { + "input": "&gEl", + "description": "Bad named entity: gEl without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&gEl" + ] + ] + }, + { + "input": "⪌", + "description": "Named entity: gEl; with a semi-colon", + "output": [ + [ + "Character", + "\u2a8c" + ] + ] + }, + { + "input": "&gacute", + "description": "Bad named entity: gacute without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&gacute" + ] + ] + }, + { + "input": "ǵ", + "description": "Named entity: gacute; with a semi-colon", + "output": [ + [ + "Character", + "\u01f5" + ] + ] + }, + { + "input": "&gamma", + "description": "Bad named entity: gamma without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&gamma" + ] + ] + }, + { + "input": "γ", + "description": "Named entity: gamma; with a semi-colon", + "output": [ + [ + "Character", + "\u03b3" + ] + ] + }, + { + "input": "&gammad", + "description": "Bad named entity: gammad without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&gammad" + ] + ] + }, + { + "input": "ϝ", + "description": "Named entity: gammad; with a semi-colon", + "output": [ + [ + "Character", + "\u03dd" + ] + ] + }, + { + "input": "&gap", + "description": "Bad named entity: gap without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&gap" + ] + ] + }, + { + "input": "⪆", + "description": "Named entity: gap; with a semi-colon", + "output": [ + [ + "Character", + "\u2a86" + ] + ] + }, + { + "input": "&gbreve", + "description": "Bad named entity: gbreve without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&gbreve" + ] + ] + }, + { + "input": "ğ", + "description": "Named entity: gbreve; with a semi-colon", + "output": [ + [ + "Character", + "\u011f" + ] + ] + }, + { + "input": "&gcirc", + "description": "Bad named entity: gcirc without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&gcirc" + ] + ] + }, + { + "input": "ĝ", + "description": "Named entity: gcirc; with a semi-colon", + "output": [ + [ + "Character", + "\u011d" + ] + ] + }, + { + "input": "&gcy", + "description": "Bad named entity: gcy without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&gcy" + ] + ] + }, + { + "input": "г", + "description": "Named entity: gcy; with a semi-colon", + "output": [ + [ + "Character", + "\u0433" + ] + ] + }, + { + "input": "&gdot", + "description": "Bad named entity: gdot without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&gdot" + ] + ] + }, + { + "input": "ġ", + "description": "Named entity: gdot; with a semi-colon", + "output": [ + [ + "Character", + "\u0121" + ] + ] + }, + { + "input": "&ge", + "description": "Bad named entity: ge without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&ge" + ] + ] + }, + { + "input": "≥", + "description": "Named entity: ge; with a semi-colon", + "output": [ + [ + "Character", + "\u2265" + ] + ] + }, + { + "input": "&gel", + "description": "Bad named entity: gel without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&gel" + ] + ] + }, + { + "input": "⋛", + "description": "Named entity: gel; with a semi-colon", + "output": [ + [ + "Character", + "\u22db" + ] + ] + }, + { + "input": "&geq", + "description": "Bad named entity: geq without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&geq" + ] + ] + }, + { + "input": "≥", + "description": "Named entity: geq; with a semi-colon", + "output": [ + [ + "Character", + "\u2265" + ] + ] + }, + { + "input": "&geqq", + "description": "Bad named entity: geqq without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&geqq" + ] + ] + }, + { + "input": "≧", + "description": "Named entity: geqq; with a semi-colon", + "output": [ + [ + "Character", + "\u2267" + ] + ] + }, + { + "input": "&geqslant", + "description": "Bad named entity: geqslant without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&geqslant" + ] + ] + }, + { + "input": "⩾", + "description": "Named entity: geqslant; with a semi-colon", + "output": [ + [ + "Character", + "\u2a7e" + ] + ] + }, + { + "input": "&ges", + "description": "Bad named entity: ges without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&ges" + ] + ] + }, + { + "input": "⩾", + "description": "Named entity: ges; with a semi-colon", + "output": [ + [ + "Character", + "\u2a7e" + ] + ] + }, + { + "input": "&gescc", + "description": "Bad named entity: gescc without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&gescc" + ] + ] + }, + { + "input": "⪩", + "description": "Named entity: gescc; with a semi-colon", + "output": [ + [ + "Character", + "\u2aa9" + ] + ] + }, + { + "input": "&gesdot", + "description": "Bad named entity: gesdot without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&gesdot" + ] + ] + }, + { + "input": "⪀", + "description": "Named entity: gesdot; with a semi-colon", + "output": [ + [ + "Character", + "\u2a80" + ] + ] + }, + { + "input": "&gesdoto", + "description": "Bad named entity: gesdoto without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&gesdoto" + ] + ] + }, + { + "input": "⪂", + "description": "Named entity: gesdoto; with a semi-colon", + "output": [ + [ + "Character", + "\u2a82" + ] + ] + }, + { + "input": "&gesdotol", + "description": "Bad named entity: gesdotol without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&gesdotol" + ] + ] + }, + { + "input": "⪄", + "description": "Named entity: gesdotol; with a semi-colon", + "output": [ + [ + "Character", + "\u2a84" + ] + ] + }, + { + "input": "&gesl", + "description": "Bad named entity: gesl without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&gesl" + ] + ] + }, + { + "input": "⋛︀", + "description": "Named entity: gesl; with a semi-colon", + "output": [ + [ + "Character", + "\u22db\ufe00" + ] + ] + }, + { + "input": "&gesles", + "description": "Bad named entity: gesles without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&gesles" + ] + ] + }, + { + "input": "⪔", + "description": "Named entity: gesles; with a semi-colon", + "output": [ + [ + "Character", + "\u2a94" + ] + ] + }, + { + "input": "&gfr", + "description": "Bad named entity: gfr without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&gfr" + ] + ] + }, + { + "input": "𝔤", + "description": "Named entity: gfr; with a semi-colon", + "output": [ + [ + "Character", + "\ud835\udd24" + ] + ] + }, + { + "input": "&gg", + "description": "Bad named entity: gg without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&gg" + ] + ] + }, + { + "input": "≫", + "description": "Named entity: gg; with a semi-colon", + "output": [ + [ + "Character", + "\u226b" + ] + ] + }, + { + "input": "&ggg", + "description": "Bad named entity: ggg without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&ggg" + ] + ] + }, + { + "input": "⋙", + "description": "Named entity: ggg; with a semi-colon", + "output": [ + [ + "Character", + "\u22d9" + ] + ] + }, + { + "input": "&gimel", + "description": "Bad named entity: gimel without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&gimel" + ] + ] + }, + { + "input": "ℷ", + "description": "Named entity: gimel; with a semi-colon", + "output": [ + [ + "Character", + "\u2137" + ] + ] + }, + { + "input": "&gjcy", + "description": "Bad named entity: gjcy without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&gjcy" + ] + ] + }, + { + "input": "ѓ", + "description": "Named entity: gjcy; with a semi-colon", + "output": [ + [ + "Character", + "\u0453" + ] + ] + }, + { + "input": "&gl", + "description": "Bad named entity: gl without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&gl" + ] + ] + }, + { + "input": "≷", + "description": "Named entity: gl; with a semi-colon", + "output": [ + [ + "Character", + "\u2277" + ] + ] + }, + { + "input": "&glE", + "description": "Bad named entity: glE without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&glE" + ] + ] + }, + { + "input": "⪒", + "description": "Named entity: glE; with a semi-colon", + "output": [ + [ + "Character", + "\u2a92" + ] + ] + }, + { + "input": "&gla", + "description": "Bad named entity: gla without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&gla" + ] + ] + }, + { + "input": "⪥", + "description": "Named entity: gla; with a semi-colon", + "output": [ + [ + "Character", + "\u2aa5" + ] + ] + }, + { + "input": "&glj", + "description": "Bad named entity: glj without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&glj" + ] + ] + }, + { + "input": "⪤", + "description": "Named entity: glj; with a semi-colon", + "output": [ + [ + "Character", + "\u2aa4" + ] + ] + }, + { + "input": "&gnE", + "description": "Bad named entity: gnE without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&gnE" + ] + ] + }, + { + "input": "≩", + "description": "Named entity: gnE; with a semi-colon", + "output": [ + [ + "Character", + "\u2269" + ] + ] + }, + { + "input": "&gnap", + "description": "Bad named entity: gnap without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&gnap" + ] + ] + }, + { + "input": "⪊", + "description": "Named entity: gnap; with a semi-colon", + "output": [ + [ + "Character", + "\u2a8a" + ] + ] + }, + { + "input": "&gnapprox", + "description": "Bad named entity: gnapprox without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&gnapprox" + ] + ] + }, + { + "input": "⪊", + "description": "Named entity: gnapprox; with a semi-colon", + "output": [ + [ + "Character", + "\u2a8a" + ] + ] + }, + { + "input": "&gne", + "description": "Bad named entity: gne without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&gne" + ] + ] + }, + { + "input": "⪈", + "description": "Named entity: gne; with a semi-colon", + "output": [ + [ + "Character", + "\u2a88" + ] + ] + }, + { + "input": "&gneq", + "description": "Bad named entity: gneq without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&gneq" + ] + ] + }, + { + "input": "⪈", + "description": "Named entity: gneq; with a semi-colon", + "output": [ + [ + "Character", + "\u2a88" + ] + ] + }, + { + "input": "&gneqq", + "description": "Bad named entity: gneqq without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&gneqq" + ] + ] + }, + { + "input": "≩", + "description": "Named entity: gneqq; with a semi-colon", + "output": [ + [ + "Character", + "\u2269" + ] + ] + }, + { + "input": "&gnsim", + "description": "Bad named entity: gnsim without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&gnsim" + ] + ] + }, + { + "input": "⋧", + "description": "Named entity: gnsim; with a semi-colon", + "output": [ + [ + "Character", + "\u22e7" + ] + ] + }, + { + "input": "&gopf", + "description": "Bad named entity: gopf without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&gopf" + ] + ] + }, + { + "input": "𝕘", + "description": "Named entity: gopf; with a semi-colon", + "output": [ + [ + "Character", + "\ud835\udd58" + ] + ] + }, + { + "input": "&grave", + "description": "Bad named entity: grave without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&grave" + ] + ] + }, + { + "input": "`", + "description": "Named entity: grave; with a semi-colon", + "output": [ + [ + "Character", + "`" + ] + ] + }, + { + "input": "&gscr", + "description": "Bad named entity: gscr without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&gscr" + ] + ] + }, + { + "input": "ℊ", + "description": "Named entity: gscr; with a semi-colon", + "output": [ + [ + "Character", + "\u210a" + ] + ] + }, + { + "input": "&gsim", + "description": "Bad named entity: gsim without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&gsim" + ] + ] + }, + { + "input": "≳", + "description": "Named entity: gsim; with a semi-colon", + "output": [ + [ + "Character", + "\u2273" + ] + ] + }, + { + "input": "&gsime", + "description": "Bad named entity: gsime without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&gsime" + ] + ] + }, + { + "input": "⪎", + "description": "Named entity: gsime; with a semi-colon", + "output": [ + [ + "Character", + "\u2a8e" + ] + ] + }, + { + "input": "&gsiml", + "description": "Bad named entity: gsiml without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&gsiml" + ] + ] + }, + { + "input": "⪐", + "description": "Named entity: gsiml; with a semi-colon", + "output": [ + [ + "Character", + "\u2a90" + ] + ] + }, + { + "input": ">", + "description": "Named entity: gt without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + ">" + ] + ] + }, + { + "input": ">", + "description": "Named entity: gt; with a semi-colon", + "output": [ + [ + "Character", + ">" + ] + ] + }, + { + "input": "⪧", + "description": "Named entity: gtcc; with a semi-colon", + "output": [ + [ + "Character", + "\u2aa7" + ] + ] + }, + { + "input": "⩺", + "description": "Named entity: gtcir; with a semi-colon", + "output": [ + [ + "Character", + "\u2a7a" + ] + ] + }, + { + "input": "⋗", + "description": "Named entity: gtdot; with a semi-colon", + "output": [ + [ + "Character", + "\u22d7" + ] + ] + }, + { + "input": "⦕", + "description": "Named entity: gtlPar; with a semi-colon", + "output": [ + [ + "Character", + "\u2995" + ] + ] + }, + { + "input": "⩼", + "description": "Named entity: gtquest; with a semi-colon", + "output": [ + [ + "Character", + "\u2a7c" + ] + ] + }, + { + "input": "⪆", + "description": "Named entity: gtrapprox; with a semi-colon", + "output": [ + [ + "Character", + "\u2a86" + ] + ] + }, + { + "input": "⥸", + "description": "Named entity: gtrarr; with a semi-colon", + "output": [ + [ + "Character", + "\u2978" + ] + ] + }, + { + "input": "⋗", + "description": "Named entity: gtrdot; with a semi-colon", + "output": [ + [ + "Character", + "\u22d7" + ] + ] + }, + { + "input": "⋛", + "description": "Named entity: gtreqless; with a semi-colon", + "output": [ + [ + "Character", + "\u22db" + ] + ] + }, + { + "input": "⪌", + "description": "Named entity: gtreqqless; with a semi-colon", + "output": [ + [ + "Character", + "\u2a8c" + ] + ] + }, + { + "input": "≷", + "description": "Named entity: gtrless; with a semi-colon", + "output": [ + [ + "Character", + "\u2277" + ] + ] + }, + { + "input": "≳", + "description": "Named entity: gtrsim; with a semi-colon", + "output": [ + [ + "Character", + "\u2273" + ] + ] + }, + { + "input": "&gvertneqq", + "description": "Bad named entity: gvertneqq without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&gvertneqq" + ] + ] + }, + { + "input": "≩︀", + "description": "Named entity: gvertneqq; with a semi-colon", + "output": [ + [ + "Character", + "\u2269\ufe00" + ] + ] + }, + { + "input": "&gvnE", + "description": "Bad named entity: gvnE without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&gvnE" + ] + ] + }, + { + "input": "≩︀", + "description": "Named entity: gvnE; with a semi-colon", + "output": [ + [ + "Character", + "\u2269\ufe00" + ] + ] + }, + { + "input": "&hArr", + "description": "Bad named entity: hArr without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&hArr" + ] + ] + }, + { + "input": "⇔", + "description": "Named entity: hArr; with a semi-colon", + "output": [ + [ + "Character", + "\u21d4" + ] + ] + }, + { + "input": "&hairsp", + "description": "Bad named entity: hairsp without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&hairsp" + ] + ] + }, + { + "input": " ", + "description": "Named entity: hairsp; with a semi-colon", + "output": [ + [ + "Character", + "\u200a" + ] + ] + }, + { + "input": "&half", + "description": "Bad named entity: half without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&half" + ] + ] + }, + { + "input": "½", + "description": "Named entity: half; with a semi-colon", + "output": [ + [ + "Character", + "\u00bd" + ] + ] + }, + { + "input": "&hamilt", + "description": "Bad named entity: hamilt without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&hamilt" + ] + ] + }, + { + "input": "ℋ", + "description": "Named entity: hamilt; with a semi-colon", + "output": [ + [ + "Character", + "\u210b" + ] + ] + }, + { + "input": "&hardcy", + "description": "Bad named entity: hardcy without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&hardcy" + ] + ] + }, + { + "input": "ъ", + "description": "Named entity: hardcy; with a semi-colon", + "output": [ + [ + "Character", + "\u044a" + ] + ] + }, + { + "input": "&harr", + "description": "Bad named entity: harr without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&harr" + ] + ] + }, + { + "input": "↔", + "description": "Named entity: harr; with a semi-colon", + "output": [ + [ + "Character", + "\u2194" + ] + ] + }, + { + "input": "&harrcir", + "description": "Bad named entity: harrcir without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&harrcir" + ] + ] + }, + { + "input": "⥈", + "description": "Named entity: harrcir; with a semi-colon", + "output": [ + [ + "Character", + "\u2948" + ] + ] + }, + { + "input": "&harrw", + "description": "Bad named entity: harrw without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&harrw" + ] + ] + }, + { + "input": "↭", + "description": "Named entity: harrw; with a semi-colon", + "output": [ + [ + "Character", + "\u21ad" + ] + ] + }, + { + "input": "&hbar", + "description": "Bad named entity: hbar without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&hbar" + ] + ] + }, + { + "input": "ℏ", + "description": "Named entity: hbar; with a semi-colon", + "output": [ + [ + "Character", + "\u210f" + ] + ] + }, + { + "input": "&hcirc", + "description": "Bad named entity: hcirc without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&hcirc" + ] + ] + }, + { + "input": "ĥ", + "description": "Named entity: hcirc; with a semi-colon", + "output": [ + [ + "Character", + "\u0125" + ] + ] + }, + { + "input": "&hearts", + "description": "Bad named entity: hearts without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&hearts" + ] + ] + }, + { + "input": "♥", + "description": "Named entity: hearts; with a semi-colon", + "output": [ + [ + "Character", + "\u2665" + ] + ] + }, + { + "input": "&heartsuit", + "description": "Bad named entity: heartsuit without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&heartsuit" + ] + ] + }, + { + "input": "♥", + "description": "Named entity: heartsuit; with a semi-colon", + "output": [ + [ + "Character", + "\u2665" + ] + ] + }, + { + "input": "&hellip", + "description": "Bad named entity: hellip without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&hellip" + ] + ] + }, + { + "input": "…", + "description": "Named entity: hellip; with a semi-colon", + "output": [ + [ + "Character", + "\u2026" + ] + ] + }, + { + "input": "&hercon", + "description": "Bad named entity: hercon without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&hercon" + ] + ] + }, + { + "input": "⊹", + "description": "Named entity: hercon; with a semi-colon", + "output": [ + [ + "Character", + "\u22b9" + ] + ] + }, + { + "input": "&hfr", + "description": "Bad named entity: hfr without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&hfr" + ] + ] + }, + { + "input": "𝔥", + "description": "Named entity: hfr; with a semi-colon", + "output": [ + [ + "Character", + "\ud835\udd25" + ] + ] + }, + { + "input": "&hksearow", + "description": "Bad named entity: hksearow without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&hksearow" + ] + ] + }, + { + "input": "⤥", + "description": "Named entity: hksearow; with a semi-colon", + "output": [ + [ + "Character", + "\u2925" + ] + ] + }, + { + "input": "&hkswarow", + "description": "Bad named entity: hkswarow without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&hkswarow" + ] + ] + }, + { + "input": "⤦", + "description": "Named entity: hkswarow; with a semi-colon", + "output": [ + [ + "Character", + "\u2926" + ] + ] + }, + { + "input": "&hoarr", + "description": "Bad named entity: hoarr without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&hoarr" + ] + ] + }, + { + "input": "⇿", + "description": "Named entity: hoarr; with a semi-colon", + "output": [ + [ + "Character", + "\u21ff" + ] + ] + }, + { + "input": "&homtht", + "description": "Bad named entity: homtht without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&homtht" + ] + ] + }, + { + "input": "∻", + "description": "Named entity: homtht; with a semi-colon", + "output": [ + [ + "Character", + "\u223b" + ] + ] + }, + { + "input": "&hookleftarrow", + "description": "Bad named entity: hookleftarrow without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&hookleftarrow" + ] + ] + }, + { + "input": "↩", + "description": "Named entity: hookleftarrow; with a semi-colon", + "output": [ + [ + "Character", + "\u21a9" + ] + ] + }, + { + "input": "&hookrightarrow", + "description": "Bad named entity: hookrightarrow without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&hookrightarrow" + ] + ] + }, + { + "input": "↪", + "description": "Named entity: hookrightarrow; with a semi-colon", + "output": [ + [ + "Character", + "\u21aa" + ] + ] + }, + { + "input": "&hopf", + "description": "Bad named entity: hopf without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&hopf" + ] + ] + }, + { + "input": "𝕙", + "description": "Named entity: hopf; with a semi-colon", + "output": [ + [ + "Character", + "\ud835\udd59" + ] + ] + }, + { + "input": "&horbar", + "description": "Bad named entity: horbar without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&horbar" + ] + ] + }, + { + "input": "―", + "description": "Named entity: horbar; with a semi-colon", + "output": [ + [ + "Character", + "\u2015" + ] + ] + }, + { + "input": "&hscr", + "description": "Bad named entity: hscr without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&hscr" + ] + ] + }, + { + "input": "𝒽", + "description": "Named entity: hscr; with a semi-colon", + "output": [ + [ + "Character", + "\ud835\udcbd" + ] + ] + }, + { + "input": "&hslash", + "description": "Bad named entity: hslash without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&hslash" + ] + ] + }, + { + "input": "ℏ", + "description": "Named entity: hslash; with a semi-colon", + "output": [ + [ + "Character", + "\u210f" + ] + ] + }, + { + "input": "&hstrok", + "description": "Bad named entity: hstrok without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&hstrok" + ] + ] + }, + { + "input": "ħ", + "description": "Named entity: hstrok; with a semi-colon", + "output": [ + [ + "Character", + "\u0127" + ] + ] + }, + { + "input": "&hybull", + "description": "Bad named entity: hybull without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&hybull" + ] + ] + }, + { + "input": "⁃", + "description": "Named entity: hybull; with a semi-colon", + "output": [ + [ + "Character", + "\u2043" + ] + ] + }, + { + "input": "&hyphen", + "description": "Bad named entity: hyphen without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&hyphen" + ] + ] + }, + { + "input": "‐", + "description": "Named entity: hyphen; with a semi-colon", + "output": [ + [ + "Character", + "\u2010" + ] + ] + }, + { + "input": "í", + "description": "Named entity: iacute without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "\u00ed" + ] + ] + }, + { + "input": "í", + "description": "Named entity: iacute; with a semi-colon", + "output": [ + [ + "Character", + "\u00ed" + ] + ] + }, + { + "input": "&ic", + "description": "Bad named entity: ic without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&ic" + ] + ] + }, + { + "input": "⁣", + "description": "Named entity: ic; with a semi-colon", + "output": [ + [ + "Character", + "\u2063" + ] + ] + }, + { + "input": "î", + "description": "Named entity: icirc without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "\u00ee" + ] + ] + }, + { + "input": "î", + "description": "Named entity: icirc; with a semi-colon", + "output": [ + [ + "Character", + "\u00ee" + ] + ] + }, + { + "input": "&icy", + "description": "Bad named entity: icy without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&icy" + ] + ] + }, + { + "input": "и", + "description": "Named entity: icy; with a semi-colon", + "output": [ + [ + "Character", + "\u0438" + ] + ] + }, + { + "input": "&iecy", + "description": "Bad named entity: iecy without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&iecy" + ] + ] + }, + { + "input": "е", + "description": "Named entity: iecy; with a semi-colon", + "output": [ + [ + "Character", + "\u0435" + ] + ] + }, + { + "input": "¡", + "description": "Named entity: iexcl without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "\u00a1" + ] + ] + }, + { + "input": "¡", + "description": "Named entity: iexcl; with a semi-colon", + "output": [ + [ + "Character", + "\u00a1" + ] + ] + }, + { + "input": "&iff", + "description": "Bad named entity: iff without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&iff" + ] + ] + }, + { + "input": "⇔", + "description": "Named entity: iff; with a semi-colon", + "output": [ + [ + "Character", + "\u21d4" + ] + ] + }, + { + "input": "&ifr", + "description": "Bad named entity: ifr without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&ifr" + ] + ] + }, + { + "input": "𝔦", + "description": "Named entity: ifr; with a semi-colon", + "output": [ + [ + "Character", + "\ud835\udd26" + ] + ] + }, + { + "input": "ì", + "description": "Named entity: igrave without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "\u00ec" + ] + ] + }, + { + "input": "ì", + "description": "Named entity: igrave; with a semi-colon", + "output": [ + [ + "Character", + "\u00ec" + ] + ] + }, + { + "input": "&ii", + "description": "Bad named entity: ii without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&ii" + ] + ] + }, + { + "input": "ⅈ", + "description": "Named entity: ii; with a semi-colon", + "output": [ + [ + "Character", + "\u2148" + ] + ] + }, + { + "input": "&iiiint", + "description": "Bad named entity: iiiint without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&iiiint" + ] + ] + }, + { + "input": "⨌", + "description": "Named entity: iiiint; with a semi-colon", + "output": [ + [ + "Character", + "\u2a0c" + ] + ] + }, + { + "input": "&iiint", + "description": "Bad named entity: iiint without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&iiint" + ] + ] + }, + { + "input": "∭", + "description": "Named entity: iiint; with a semi-colon", + "output": [ + [ + "Character", + "\u222d" + ] + ] + }, + { + "input": "&iinfin", + "description": "Bad named entity: iinfin without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&iinfin" + ] + ] + }, + { + "input": "⧜", + "description": "Named entity: iinfin; with a semi-colon", + "output": [ + [ + "Character", + "\u29dc" + ] + ] + }, + { + "input": "&iiota", + "description": "Bad named entity: iiota without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&iiota" + ] + ] + }, + { + "input": "℩", + "description": "Named entity: iiota; with a semi-colon", + "output": [ + [ + "Character", + "\u2129" + ] + ] + }, + { + "input": "&ijlig", + "description": "Bad named entity: ijlig without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&ijlig" + ] + ] + }, + { + "input": "ij", + "description": "Named entity: ijlig; with a semi-colon", + "output": [ + [ + "Character", + "\u0133" + ] + ] + }, + { + "input": "&imacr", + "description": "Bad named entity: imacr without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&imacr" + ] + ] + }, + { + "input": "ī", + "description": "Named entity: imacr; with a semi-colon", + "output": [ + [ + "Character", + "\u012b" + ] + ] + }, + { + "input": "&image", + "description": "Bad named entity: image without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&image" + ] + ] + }, + { + "input": "ℑ", + "description": "Named entity: image; with a semi-colon", + "output": [ + [ + "Character", + "\u2111" + ] + ] + }, + { + "input": "&imagline", + "description": "Bad named entity: imagline without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&imagline" + ] + ] + }, + { + "input": "ℐ", + "description": "Named entity: imagline; with a semi-colon", + "output": [ + [ + "Character", + "\u2110" + ] + ] + }, + { + "input": "&imagpart", + "description": "Bad named entity: imagpart without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&imagpart" + ] + ] + }, + { + "input": "ℑ", + "description": "Named entity: imagpart; with a semi-colon", + "output": [ + [ + "Character", + "\u2111" + ] + ] + }, + { + "input": "&imath", + "description": "Bad named entity: imath without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&imath" + ] + ] + }, + { + "input": "ı", + "description": "Named entity: imath; with a semi-colon", + "output": [ + [ + "Character", + "\u0131" + ] + ] + }, + { + "input": "&imof", + "description": "Bad named entity: imof without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&imof" + ] + ] + }, + { + "input": "⊷", + "description": "Named entity: imof; with a semi-colon", + "output": [ + [ + "Character", + "\u22b7" + ] + ] + }, + { + "input": "&imped", + "description": "Bad named entity: imped without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&imped" + ] + ] + }, + { + "input": "Ƶ", + "description": "Named entity: imped; with a semi-colon", + "output": [ + [ + "Character", + "\u01b5" + ] + ] + }, + { + "input": "&in", + "description": "Bad named entity: in without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&in" + ] + ] + }, + { + "input": "∈", + "description": "Named entity: in; with a semi-colon", + "output": [ + [ + "Character", + "\u2208" + ] + ] + }, + { + "input": "&incare", + "description": "Bad named entity: incare without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&incare" + ] + ] + }, + { + "input": "℅", + "description": "Named entity: incare; with a semi-colon", + "output": [ + [ + "Character", + "\u2105" + ] + ] + }, + { + "input": "&infin", + "description": "Bad named entity: infin without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&infin" + ] + ] + }, + { + "input": "∞", + "description": "Named entity: infin; with a semi-colon", + "output": [ + [ + "Character", + "\u221e" + ] + ] + }, + { + "input": "&infintie", + "description": "Bad named entity: infintie without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&infintie" + ] + ] + }, + { + "input": "⧝", + "description": "Named entity: infintie; with a semi-colon", + "output": [ + [ + "Character", + "\u29dd" + ] + ] + }, + { + "input": "&inodot", + "description": "Bad named entity: inodot without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&inodot" + ] + ] + }, + { + "input": "ı", + "description": "Named entity: inodot; with a semi-colon", + "output": [ + [ + "Character", + "\u0131" + ] + ] + }, + { + "input": "&int", + "description": "Bad named entity: int without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&int" + ] + ] + }, + { + "input": "∫", + "description": "Named entity: int; with a semi-colon", + "output": [ + [ + "Character", + "\u222b" + ] + ] + }, + { + "input": "&intcal", + "description": "Bad named entity: intcal without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&intcal" + ] + ] + }, + { + "input": "⊺", + "description": "Named entity: intcal; with a semi-colon", + "output": [ + [ + "Character", + "\u22ba" + ] + ] + }, + { + "input": "&integers", + "description": "Bad named entity: integers without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&integers" + ] + ] + }, + { + "input": "ℤ", + "description": "Named entity: integers; with a semi-colon", + "output": [ + [ + "Character", + "\u2124" + ] + ] + }, + { + "input": "&intercal", + "description": "Bad named entity: intercal without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&intercal" + ] + ] + }, + { + "input": "⊺", + "description": "Named entity: intercal; with a semi-colon", + "output": [ + [ + "Character", + "\u22ba" + ] + ] + }, + { + "input": "&intlarhk", + "description": "Bad named entity: intlarhk without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&intlarhk" + ] + ] + }, + { + "input": "⨗", + "description": "Named entity: intlarhk; with a semi-colon", + "output": [ + [ + "Character", + "\u2a17" + ] + ] + }, + { + "input": "&intprod", + "description": "Bad named entity: intprod without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&intprod" + ] + ] + }, + { + "input": "⨼", + "description": "Named entity: intprod; with a semi-colon", + "output": [ + [ + "Character", + "\u2a3c" + ] + ] + }, + { + "input": "&iocy", + "description": "Bad named entity: iocy without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&iocy" + ] + ] + }, + { + "input": "ё", + "description": "Named entity: iocy; with a semi-colon", + "output": [ + [ + "Character", + "\u0451" + ] + ] + }, + { + "input": "&iogon", + "description": "Bad named entity: iogon without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&iogon" + ] + ] + }, + { + "input": "į", + "description": "Named entity: iogon; with a semi-colon", + "output": [ + [ + "Character", + "\u012f" + ] + ] + }, + { + "input": "&iopf", + "description": "Bad named entity: iopf without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&iopf" + ] + ] + }, + { + "input": "𝕚", + "description": "Named entity: iopf; with a semi-colon", + "output": [ + [ + "Character", + "\ud835\udd5a" + ] + ] + }, + { + "input": "&iota", + "description": "Bad named entity: iota without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&iota" + ] + ] + }, + { + "input": "ι", + "description": "Named entity: iota; with a semi-colon", + "output": [ + [ + "Character", + "\u03b9" + ] + ] + }, + { + "input": "&iprod", + "description": "Bad named entity: iprod without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&iprod" + ] + ] + }, + { + "input": "⨼", + "description": "Named entity: iprod; with a semi-colon", + "output": [ + [ + "Character", + "\u2a3c" + ] + ] + }, + { + "input": "¿", + "description": "Named entity: iquest without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "\u00bf" + ] + ] + }, + { + "input": "¿", + "description": "Named entity: iquest; with a semi-colon", + "output": [ + [ + "Character", + "\u00bf" + ] + ] + }, + { + "input": "&iscr", + "description": "Bad named entity: iscr without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&iscr" + ] + ] + }, + { + "input": "𝒾", + "description": "Named entity: iscr; with a semi-colon", + "output": [ + [ + "Character", + "\ud835\udcbe" + ] + ] + }, + { + "input": "&isin", + "description": "Bad named entity: isin without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&isin" + ] + ] + }, + { + "input": "∈", + "description": "Named entity: isin; with a semi-colon", + "output": [ + [ + "Character", + "\u2208" + ] + ] + }, + { + "input": "&isinE", + "description": "Bad named entity: isinE without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&isinE" + ] + ] + }, + { + "input": "⋹", + "description": "Named entity: isinE; with a semi-colon", + "output": [ + [ + "Character", + "\u22f9" + ] + ] + }, + { + "input": "&isindot", + "description": "Bad named entity: isindot without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&isindot" + ] + ] + }, + { + "input": "⋵", + "description": "Named entity: isindot; with a semi-colon", + "output": [ + [ + "Character", + "\u22f5" + ] + ] + }, + { + "input": "&isins", + "description": "Bad named entity: isins without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&isins" + ] + ] + }, + { + "input": "⋴", + "description": "Named entity: isins; with a semi-colon", + "output": [ + [ + "Character", + "\u22f4" + ] + ] + }, + { + "input": "&isinsv", + "description": "Bad named entity: isinsv without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&isinsv" + ] + ] + }, + { + "input": "⋳", + "description": "Named entity: isinsv; with a semi-colon", + "output": [ + [ + "Character", + "\u22f3" + ] + ] + }, + { + "input": "&isinv", + "description": "Bad named entity: isinv without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&isinv" + ] + ] + }, + { + "input": "∈", + "description": "Named entity: isinv; with a semi-colon", + "output": [ + [ + "Character", + "\u2208" + ] + ] + }, + { + "input": "&it", + "description": "Bad named entity: it without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&it" + ] + ] + }, + { + "input": "⁢", + "description": "Named entity: it; with a semi-colon", + "output": [ + [ + "Character", + "\u2062" + ] + ] + }, + { + "input": "&itilde", + "description": "Bad named entity: itilde without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&itilde" + ] + ] + }, + { + "input": "ĩ", + "description": "Named entity: itilde; with a semi-colon", + "output": [ + [ + "Character", + "\u0129" + ] + ] + }, + { + "input": "&iukcy", + "description": "Bad named entity: iukcy without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&iukcy" + ] + ] + }, + { + "input": "і", + "description": "Named entity: iukcy; with a semi-colon", + "output": [ + [ + "Character", + "\u0456" + ] + ] + }, + { + "input": "ï", + "description": "Named entity: iuml without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "\u00ef" + ] + ] + }, + { + "input": "ï", + "description": "Named entity: iuml; with a semi-colon", + "output": [ + [ + "Character", + "\u00ef" + ] + ] + }, + { + "input": "&jcirc", + "description": "Bad named entity: jcirc without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&jcirc" + ] + ] + }, + { + "input": "ĵ", + "description": "Named entity: jcirc; with a semi-colon", + "output": [ + [ + "Character", + "\u0135" + ] + ] + }, + { + "input": "&jcy", + "description": "Bad named entity: jcy without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&jcy" + ] + ] + }, + { + "input": "й", + "description": "Named entity: jcy; with a semi-colon", + "output": [ + [ + "Character", + "\u0439" + ] + ] + }, + { + "input": "&jfr", + "description": "Bad named entity: jfr without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&jfr" + ] + ] + }, + { + "input": "𝔧", + "description": "Named entity: jfr; with a semi-colon", + "output": [ + [ + "Character", + "\ud835\udd27" + ] + ] + }, + { + "input": "&jmath", + "description": "Bad named entity: jmath without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&jmath" + ] + ] + }, + { + "input": "ȷ", + "description": "Named entity: jmath; with a semi-colon", + "output": [ + [ + "Character", + "\u0237" + ] + ] + }, + { + "input": "&jopf", + "description": "Bad named entity: jopf without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&jopf" + ] + ] + }, + { + "input": "𝕛", + "description": "Named entity: jopf; with a semi-colon", + "output": [ + [ + "Character", + "\ud835\udd5b" + ] + ] + }, + { + "input": "&jscr", + "description": "Bad named entity: jscr without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&jscr" + ] + ] + }, + { + "input": "𝒿", + "description": "Named entity: jscr; with a semi-colon", + "output": [ + [ + "Character", + "\ud835\udcbf" + ] + ] + }, + { + "input": "&jsercy", + "description": "Bad named entity: jsercy without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&jsercy" + ] + ] + }, + { + "input": "ј", + "description": "Named entity: jsercy; with a semi-colon", + "output": [ + [ + "Character", + "\u0458" + ] + ] + }, + { + "input": "&jukcy", + "description": "Bad named entity: jukcy without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&jukcy" + ] + ] + }, + { + "input": "є", + "description": "Named entity: jukcy; with a semi-colon", + "output": [ + [ + "Character", + "\u0454" + ] + ] + }, + { + "input": "&kappa", + "description": "Bad named entity: kappa without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&kappa" + ] + ] + }, + { + "input": "κ", + "description": "Named entity: kappa; with a semi-colon", + "output": [ + [ + "Character", + "\u03ba" + ] + ] + }, + { + "input": "&kappav", + "description": "Bad named entity: kappav without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&kappav" + ] + ] + }, + { + "input": "ϰ", + "description": "Named entity: kappav; with a semi-colon", + "output": [ + [ + "Character", + "\u03f0" + ] + ] + }, + { + "input": "&kcedil", + "description": "Bad named entity: kcedil without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&kcedil" + ] + ] + }, + { + "input": "ķ", + "description": "Named entity: kcedil; with a semi-colon", + "output": [ + [ + "Character", + "\u0137" + ] + ] + }, + { + "input": "&kcy", + "description": "Bad named entity: kcy without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&kcy" + ] + ] + }, + { + "input": "к", + "description": "Named entity: kcy; with a semi-colon", + "output": [ + [ + "Character", + "\u043a" + ] + ] + }, + { + "input": "&kfr", + "description": "Bad named entity: kfr without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&kfr" + ] + ] + }, + { + "input": "𝔨", + "description": "Named entity: kfr; with a semi-colon", + "output": [ + [ + "Character", + "\ud835\udd28" + ] + ] + }, + { + "input": "&kgreen", + "description": "Bad named entity: kgreen without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&kgreen" + ] + ] + }, + { + "input": "ĸ", + "description": "Named entity: kgreen; with a semi-colon", + "output": [ + [ + "Character", + "\u0138" + ] + ] + }, + { + "input": "&khcy", + "description": "Bad named entity: khcy without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&khcy" + ] + ] + }, + { + "input": "х", + "description": "Named entity: khcy; with a semi-colon", + "output": [ + [ + "Character", + "\u0445" + ] + ] + }, + { + "input": "&kjcy", + "description": "Bad named entity: kjcy without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&kjcy" + ] + ] + }, + { + "input": "ќ", + "description": "Named entity: kjcy; with a semi-colon", + "output": [ + [ + "Character", + "\u045c" + ] + ] + }, + { + "input": "&kopf", + "description": "Bad named entity: kopf without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&kopf" + ] + ] + }, + { + "input": "𝕜", + "description": "Named entity: kopf; with a semi-colon", + "output": [ + [ + "Character", + "\ud835\udd5c" + ] + ] + }, + { + "input": "&kscr", + "description": "Bad named entity: kscr without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&kscr" + ] + ] + }, + { + "input": "𝓀", + "description": "Named entity: kscr; with a semi-colon", + "output": [ + [ + "Character", + "\ud835\udcc0" + ] + ] + }, + { + "input": "&lAarr", + "description": "Bad named entity: lAarr without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&lAarr" + ] + ] + }, + { + "input": "⇚", + "description": "Named entity: lAarr; with a semi-colon", + "output": [ + [ + "Character", + "\u21da" + ] + ] + }, + { + "input": "&lArr", + "description": "Bad named entity: lArr without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&lArr" + ] + ] + }, + { + "input": "⇐", + "description": "Named entity: lArr; with a semi-colon", + "output": [ + [ + "Character", + "\u21d0" + ] + ] + }, + { + "input": "&lAtail", + "description": "Bad named entity: lAtail without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&lAtail" + ] + ] + }, + { + "input": "⤛", + "description": "Named entity: lAtail; with a semi-colon", + "output": [ + [ + "Character", + "\u291b" + ] + ] + }, + { + "input": "&lBarr", + "description": "Bad named entity: lBarr without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&lBarr" + ] + ] + }, + { + "input": "⤎", + "description": "Named entity: lBarr; with a semi-colon", + "output": [ + [ + "Character", + "\u290e" + ] + ] + }, + { + "input": "&lE", + "description": "Bad named entity: lE without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&lE" + ] + ] + }, + { + "input": "≦", + "description": "Named entity: lE; with a semi-colon", + "output": [ + [ + "Character", + "\u2266" + ] + ] + }, + { + "input": "&lEg", + "description": "Bad named entity: lEg without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&lEg" + ] + ] + }, + { + "input": "⪋", + "description": "Named entity: lEg; with a semi-colon", + "output": [ + [ + "Character", + "\u2a8b" + ] + ] + }, + { + "input": "&lHar", + "description": "Bad named entity: lHar without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&lHar" + ] + ] + }, + { + "input": "⥢", + "description": "Named entity: lHar; with a semi-colon", + "output": [ + [ + "Character", + "\u2962" + ] + ] + }, + { + "input": "&lacute", + "description": "Bad named entity: lacute without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&lacute" + ] + ] + }, + { + "input": "ĺ", + "description": "Named entity: lacute; with a semi-colon", + "output": [ + [ + "Character", + "\u013a" + ] + ] + }, + { + "input": "&laemptyv", + "description": "Bad named entity: laemptyv without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&laemptyv" + ] + ] + }, + { + "input": "⦴", + "description": "Named entity: laemptyv; with a semi-colon", + "output": [ + [ + "Character", + "\u29b4" + ] + ] + }, + { + "input": "&lagran", + "description": "Bad named entity: lagran without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&lagran" + ] + ] + }, + { + "input": "ℒ", + "description": "Named entity: lagran; with a semi-colon", + "output": [ + [ + "Character", + "\u2112" + ] + ] + }, + { + "input": "&lambda", + "description": "Bad named entity: lambda without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&lambda" + ] + ] + }, + { + "input": "λ", + "description": "Named entity: lambda; with a semi-colon", + "output": [ + [ + "Character", + "\u03bb" + ] + ] + }, + { + "input": "&lang", + "description": "Bad named entity: lang without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&lang" + ] + ] + }, + { + "input": "⟨", + "description": "Named entity: lang; with a semi-colon", + "output": [ + [ + "Character", + "\u27e8" + ] + ] + }, + { + "input": "&langd", + "description": "Bad named entity: langd without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&langd" + ] + ] + }, + { + "input": "⦑", + "description": "Named entity: langd; with a semi-colon", + "output": [ + [ + "Character", + "\u2991" + ] + ] + }, + { + "input": "&langle", + "description": "Bad named entity: langle without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&langle" + ] + ] + }, + { + "input": "⟨", + "description": "Named entity: langle; with a semi-colon", + "output": [ + [ + "Character", + "\u27e8" + ] + ] + }, + { + "input": "&lap", + "description": "Bad named entity: lap without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&lap" + ] + ] + }, + { + "input": "⪅", + "description": "Named entity: lap; with a semi-colon", + "output": [ + [ + "Character", + "\u2a85" + ] + ] + }, + { + "input": "«", + "description": "Named entity: laquo without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "\u00ab" + ] + ] + }, + { + "input": "«", + "description": "Named entity: laquo; with a semi-colon", + "output": [ + [ + "Character", + "\u00ab" + ] + ] + }, + { + "input": "&larr", + "description": "Bad named entity: larr without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&larr" + ] + ] + }, + { + "input": "←", + "description": "Named entity: larr; with a semi-colon", + "output": [ + [ + "Character", + "\u2190" + ] + ] + }, + { + "input": "&larrb", + "description": "Bad named entity: larrb without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&larrb" + ] + ] + }, + { + "input": "⇤", + "description": "Named entity: larrb; with a semi-colon", + "output": [ + [ + "Character", + "\u21e4" + ] + ] + }, + { + "input": "&larrbfs", + "description": "Bad named entity: larrbfs without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&larrbfs" + ] + ] + }, + { + "input": "⤟", + "description": "Named entity: larrbfs; with a semi-colon", + "output": [ + [ + "Character", + "\u291f" + ] + ] + }, + { + "input": "&larrfs", + "description": "Bad named entity: larrfs without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&larrfs" + ] + ] + }, + { + "input": "⤝", + "description": "Named entity: larrfs; with a semi-colon", + "output": [ + [ + "Character", + "\u291d" + ] + ] + }, + { + "input": "&larrhk", + "description": "Bad named entity: larrhk without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&larrhk" + ] + ] + }, + { + "input": "↩", + "description": "Named entity: larrhk; with a semi-colon", + "output": [ + [ + "Character", + "\u21a9" + ] + ] + }, + { + "input": "&larrlp", + "description": "Bad named entity: larrlp without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&larrlp" + ] + ] + }, + { + "input": "↫", + "description": "Named entity: larrlp; with a semi-colon", + "output": [ + [ + "Character", + "\u21ab" + ] + ] + }, + { + "input": "&larrpl", + "description": "Bad named entity: larrpl without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&larrpl" + ] + ] + }, + { + "input": "⤹", + "description": "Named entity: larrpl; with a semi-colon", + "output": [ + [ + "Character", + "\u2939" + ] + ] + }, + { + "input": "&larrsim", + "description": "Bad named entity: larrsim without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&larrsim" + ] + ] + }, + { + "input": "⥳", + "description": "Named entity: larrsim; with a semi-colon", + "output": [ + [ + "Character", + "\u2973" + ] + ] + }, + { + "input": "&larrtl", + "description": "Bad named entity: larrtl without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&larrtl" + ] + ] + }, + { + "input": "↢", + "description": "Named entity: larrtl; with a semi-colon", + "output": [ + [ + "Character", + "\u21a2" + ] + ] + }, + { + "input": "&lat", + "description": "Bad named entity: lat without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&lat" + ] + ] + }, + { + "input": "⪫", + "description": "Named entity: lat; with a semi-colon", + "output": [ + [ + "Character", + "\u2aab" + ] + ] + }, + { + "input": "&latail", + "description": "Bad named entity: latail without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&latail" + ] + ] + }, + { + "input": "⤙", + "description": "Named entity: latail; with a semi-colon", + "output": [ + [ + "Character", + "\u2919" + ] + ] + }, + { + "input": "&late", + "description": "Bad named entity: late without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&late" + ] + ] + }, + { + "input": "⪭", + "description": "Named entity: late; with a semi-colon", + "output": [ + [ + "Character", + "\u2aad" + ] + ] + }, + { + "input": "&lates", + "description": "Bad named entity: lates without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&lates" + ] + ] + }, + { + "input": "⪭︀", + "description": "Named entity: lates; with a semi-colon", + "output": [ + [ + "Character", + "\u2aad\ufe00" + ] + ] + }, + { + "input": "&lbarr", + "description": "Bad named entity: lbarr without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&lbarr" + ] + ] + }, + { + "input": "⤌", + "description": "Named entity: lbarr; with a semi-colon", + "output": [ + [ + "Character", + "\u290c" + ] + ] + }, + { + "input": "&lbbrk", + "description": "Bad named entity: lbbrk without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&lbbrk" + ] + ] + }, + { + "input": "❲", + "description": "Named entity: lbbrk; with a semi-colon", + "output": [ + [ + "Character", + "\u2772" + ] + ] + }, + { + "input": "&lbrace", + "description": "Bad named entity: lbrace without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&lbrace" + ] + ] + }, + { + "input": "{", + "description": "Named entity: lbrace; with a semi-colon", + "output": [ + [ + "Character", + "{" + ] + ] + }, + { + "input": "&lbrack", + "description": "Bad named entity: lbrack without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&lbrack" + ] + ] + }, + { + "input": "[", + "description": "Named entity: lbrack; with a semi-colon", + "output": [ + [ + "Character", + "[" + ] + ] + }, + { + "input": "&lbrke", + "description": "Bad named entity: lbrke without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&lbrke" + ] + ] + }, + { + "input": "⦋", + "description": "Named entity: lbrke; with a semi-colon", + "output": [ + [ + "Character", + "\u298b" + ] + ] + }, + { + "input": "&lbrksld", + "description": "Bad named entity: lbrksld without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&lbrksld" + ] + ] + }, + { + "input": "⦏", + "description": "Named entity: lbrksld; with a semi-colon", + "output": [ + [ + "Character", + "\u298f" + ] + ] + }, + { + "input": "&lbrkslu", + "description": "Bad named entity: lbrkslu without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&lbrkslu" + ] + ] + }, + { + "input": "⦍", + "description": "Named entity: lbrkslu; with a semi-colon", + "output": [ + [ + "Character", + "\u298d" + ] + ] + }, + { + "input": "&lcaron", + "description": "Bad named entity: lcaron without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&lcaron" + ] + ] + }, + { + "input": "ľ", + "description": "Named entity: lcaron; with a semi-colon", + "output": [ + [ + "Character", + "\u013e" + ] + ] + }, + { + "input": "&lcedil", + "description": "Bad named entity: lcedil without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&lcedil" + ] + ] + }, + { + "input": "ļ", + "description": "Named entity: lcedil; with a semi-colon", + "output": [ + [ + "Character", + "\u013c" + ] + ] + }, + { + "input": "&lceil", + "description": "Bad named entity: lceil without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&lceil" + ] + ] + }, + { + "input": "⌈", + "description": "Named entity: lceil; with a semi-colon", + "output": [ + [ + "Character", + "\u2308" + ] + ] + }, + { + "input": "&lcub", + "description": "Bad named entity: lcub without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&lcub" + ] + ] + }, + { + "input": "{", + "description": "Named entity: lcub; with a semi-colon", + "output": [ + [ + "Character", + "{" + ] + ] + }, + { + "input": "&lcy", + "description": "Bad named entity: lcy without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&lcy" + ] + ] + }, + { + "input": "л", + "description": "Named entity: lcy; with a semi-colon", + "output": [ + [ + "Character", + "\u043b" + ] + ] + }, + { + "input": "&ldca", + "description": "Bad named entity: ldca without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&ldca" + ] + ] + }, + { + "input": "⤶", + "description": "Named entity: ldca; with a semi-colon", + "output": [ + [ + "Character", + "\u2936" + ] + ] + }, + { + "input": "&ldquo", + "description": "Bad named entity: ldquo without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&ldquo" + ] + ] + }, + { + "input": "“", + "description": "Named entity: ldquo; with a semi-colon", + "output": [ + [ + "Character", + "\u201c" + ] + ] + }, + { + "input": "&ldquor", + "description": "Bad named entity: ldquor without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&ldquor" + ] + ] + }, + { + "input": "„", + "description": "Named entity: ldquor; with a semi-colon", + "output": [ + [ + "Character", + "\u201e" + ] + ] + }, + { + "input": "&ldrdhar", + "description": "Bad named entity: ldrdhar without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&ldrdhar" + ] + ] + }, + { + "input": "⥧", + "description": "Named entity: ldrdhar; with a semi-colon", + "output": [ + [ + "Character", + "\u2967" + ] + ] + }, + { + "input": "&ldrushar", + "description": "Bad named entity: ldrushar without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&ldrushar" + ] + ] + }, + { + "input": "⥋", + "description": "Named entity: ldrushar; with a semi-colon", + "output": [ + [ + "Character", + "\u294b" + ] + ] + }, + { + "input": "&ldsh", + "description": "Bad named entity: ldsh without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&ldsh" + ] + ] + }, + { + "input": "↲", + "description": "Named entity: ldsh; with a semi-colon", + "output": [ + [ + "Character", + "\u21b2" + ] + ] + }, + { + "input": "&le", + "description": "Bad named entity: le without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&le" + ] + ] + }, + { + "input": "≤", + "description": "Named entity: le; with a semi-colon", + "output": [ + [ + "Character", + "\u2264" + ] + ] + }, + { + "input": "&leftarrow", + "description": "Bad named entity: leftarrow without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&leftarrow" + ] + ] + }, + { + "input": "←", + "description": "Named entity: leftarrow; with a semi-colon", + "output": [ + [ + "Character", + "\u2190" + ] + ] + }, + { + "input": "&leftarrowtail", + "description": "Bad named entity: leftarrowtail without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&leftarrowtail" + ] + ] + }, + { + "input": "↢", + "description": "Named entity: leftarrowtail; with a semi-colon", + "output": [ + [ + "Character", + "\u21a2" + ] + ] + }, + { + "input": "&leftharpoondown", + "description": "Bad named entity: leftharpoondown without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&leftharpoondown" + ] + ] + }, + { + "input": "↽", + "description": "Named entity: leftharpoondown; with a semi-colon", + "output": [ + [ + "Character", + "\u21bd" + ] + ] + }, + { + "input": "&leftharpoonup", + "description": "Bad named entity: leftharpoonup without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&leftharpoonup" + ] + ] + }, + { + "input": "↼", + "description": "Named entity: leftharpoonup; with a semi-colon", + "output": [ + [ + "Character", + "\u21bc" + ] + ] + }, + { + "input": "&leftleftarrows", + "description": "Bad named entity: leftleftarrows without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&leftleftarrows" + ] + ] + }, + { + "input": "⇇", + "description": "Named entity: leftleftarrows; with a semi-colon", + "output": [ + [ + "Character", + "\u21c7" + ] + ] + }, + { + "input": "&leftrightarrow", + "description": "Bad named entity: leftrightarrow without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&leftrightarrow" + ] + ] + }, + { + "input": "↔", + "description": "Named entity: leftrightarrow; with a semi-colon", + "output": [ + [ + "Character", + "\u2194" + ] + ] + }, + { + "input": "&leftrightarrows", + "description": "Bad named entity: leftrightarrows without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&leftrightarrows" + ] + ] + }, + { + "input": "⇆", + "description": "Named entity: leftrightarrows; with a semi-colon", + "output": [ + [ + "Character", + "\u21c6" + ] + ] + }, + { + "input": "&leftrightharpoons", + "description": "Bad named entity: leftrightharpoons without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&leftrightharpoons" + ] + ] + }, + { + "input": "⇋", + "description": "Named entity: leftrightharpoons; with a semi-colon", + "output": [ + [ + "Character", + "\u21cb" + ] + ] + }, + { + "input": "&leftrightsquigarrow", + "description": "Bad named entity: leftrightsquigarrow without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&leftrightsquigarrow" + ] + ] + }, + { + "input": "↭", + "description": "Named entity: leftrightsquigarrow; with a semi-colon", + "output": [ + [ + "Character", + "\u21ad" + ] + ] + }, + { + "input": "&leftthreetimes", + "description": "Bad named entity: leftthreetimes without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&leftthreetimes" + ] + ] + }, + { + "input": "⋋", + "description": "Named entity: leftthreetimes; with a semi-colon", + "output": [ + [ + "Character", + "\u22cb" + ] + ] + }, + { + "input": "&leg", + "description": "Bad named entity: leg without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&leg" + ] + ] + }, + { + "input": "⋚", + "description": "Named entity: leg; with a semi-colon", + "output": [ + [ + "Character", + "\u22da" + ] + ] + }, + { + "input": "&leq", + "description": "Bad named entity: leq without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&leq" + ] + ] + }, + { + "input": "≤", + "description": "Named entity: leq; with a semi-colon", + "output": [ + [ + "Character", + "\u2264" + ] + ] + }, + { + "input": "&leqq", + "description": "Bad named entity: leqq without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&leqq" + ] + ] + }, + { + "input": "≦", + "description": "Named entity: leqq; with a semi-colon", + "output": [ + [ + "Character", + "\u2266" + ] + ] + }, + { + "input": "&leqslant", + "description": "Bad named entity: leqslant without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&leqslant" + ] + ] + }, + { + "input": "⩽", + "description": "Named entity: leqslant; with a semi-colon", + "output": [ + [ + "Character", + "\u2a7d" + ] + ] + }, + { + "input": "&les", + "description": "Bad named entity: les without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&les" + ] + ] + }, + { + "input": "⩽", + "description": "Named entity: les; with a semi-colon", + "output": [ + [ + "Character", + "\u2a7d" + ] + ] + }, + { + "input": "&lescc", + "description": "Bad named entity: lescc without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&lescc" + ] + ] + }, + { + "input": "⪨", + "description": "Named entity: lescc; with a semi-colon", + "output": [ + [ + "Character", + "\u2aa8" + ] + ] + }, + { + "input": "&lesdot", + "description": "Bad named entity: lesdot without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&lesdot" + ] + ] + }, + { + "input": "⩿", + "description": "Named entity: lesdot; with a semi-colon", + "output": [ + [ + "Character", + "\u2a7f" + ] + ] + }, + { + "input": "&lesdoto", + "description": "Bad named entity: lesdoto without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&lesdoto" + ] + ] + }, + { + "input": "⪁", + "description": "Named entity: lesdoto; with a semi-colon", + "output": [ + [ + "Character", + "\u2a81" + ] + ] + }, + { + "input": "&lesdotor", + "description": "Bad named entity: lesdotor without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&lesdotor" + ] + ] + }, + { + "input": "⪃", + "description": "Named entity: lesdotor; with a semi-colon", + "output": [ + [ + "Character", + "\u2a83" + ] + ] + }, + { + "input": "&lesg", + "description": "Bad named entity: lesg without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&lesg" + ] + ] + }, + { + "input": "⋚︀", + "description": "Named entity: lesg; with a semi-colon", + "output": [ + [ + "Character", + "\u22da\ufe00" + ] + ] + }, + { + "input": "&lesges", + "description": "Bad named entity: lesges without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&lesges" + ] + ] + }, + { + "input": "⪓", + "description": "Named entity: lesges; with a semi-colon", + "output": [ + [ + "Character", + "\u2a93" + ] + ] + }, + { + "input": "&lessapprox", + "description": "Bad named entity: lessapprox without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&lessapprox" + ] + ] + }, + { + "input": "⪅", + "description": "Named entity: lessapprox; with a semi-colon", + "output": [ + [ + "Character", + "\u2a85" + ] + ] + }, + { + "input": "&lessdot", + "description": "Bad named entity: lessdot without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&lessdot" + ] + ] + }, + { + "input": "⋖", + "description": "Named entity: lessdot; with a semi-colon", + "output": [ + [ + "Character", + "\u22d6" + ] + ] + }, + { + "input": "&lesseqgtr", + "description": "Bad named entity: lesseqgtr without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&lesseqgtr" + ] + ] + }, + { + "input": "⋚", + "description": "Named entity: lesseqgtr; with a semi-colon", + "output": [ + [ + "Character", + "\u22da" + ] + ] + }, + { + "input": "&lesseqqgtr", + "description": "Bad named entity: lesseqqgtr without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&lesseqqgtr" + ] + ] + }, + { + "input": "⪋", + "description": "Named entity: lesseqqgtr; with a semi-colon", + "output": [ + [ + "Character", + "\u2a8b" + ] + ] + }, + { + "input": "&lessgtr", + "description": "Bad named entity: lessgtr without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&lessgtr" + ] + ] + }, + { + "input": "≶", + "description": "Named entity: lessgtr; with a semi-colon", + "output": [ + [ + "Character", + "\u2276" + ] + ] + }, + { + "input": "&lesssim", + "description": "Bad named entity: lesssim without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&lesssim" + ] + ] + }, + { + "input": "≲", + "description": "Named entity: lesssim; with a semi-colon", + "output": [ + [ + "Character", + "\u2272" + ] + ] + }, + { + "input": "&lfisht", + "description": "Bad named entity: lfisht without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&lfisht" + ] + ] + }, + { + "input": "⥼", + "description": "Named entity: lfisht; with a semi-colon", + "output": [ + [ + "Character", + "\u297c" + ] + ] + }, + { + "input": "&lfloor", + "description": "Bad named entity: lfloor without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&lfloor" + ] + ] + }, + { + "input": "⌊", + "description": "Named entity: lfloor; with a semi-colon", + "output": [ + [ + "Character", + "\u230a" + ] + ] + }, + { + "input": "&lfr", + "description": "Bad named entity: lfr without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&lfr" + ] + ] + }, + { + "input": "𝔩", + "description": "Named entity: lfr; with a semi-colon", + "output": [ + [ + "Character", + "\ud835\udd29" + ] + ] + }, + { + "input": "&lg", + "description": "Bad named entity: lg without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&lg" + ] + ] + }, + { + "input": "≶", + "description": "Named entity: lg; with a semi-colon", + "output": [ + [ + "Character", + "\u2276" + ] + ] + }, + { + "input": "&lgE", + "description": "Bad named entity: lgE without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&lgE" + ] + ] + }, + { + "input": "⪑", + "description": "Named entity: lgE; with a semi-colon", + "output": [ + [ + "Character", + "\u2a91" + ] + ] + }, + { + "input": "&lhard", + "description": "Bad named entity: lhard without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&lhard" + ] + ] + }, + { + "input": "↽", + "description": "Named entity: lhard; with a semi-colon", + "output": [ + [ + "Character", + "\u21bd" + ] + ] + }, + { + "input": "&lharu", + "description": "Bad named entity: lharu without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&lharu" + ] + ] + }, + { + "input": "↼", + "description": "Named entity: lharu; with a semi-colon", + "output": [ + [ + "Character", + "\u21bc" + ] + ] + }, + { + "input": "&lharul", + "description": "Bad named entity: lharul without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&lharul" + ] + ] + }, + { + "input": "⥪", + "description": "Named entity: lharul; with a semi-colon", + "output": [ + [ + "Character", + "\u296a" + ] + ] + }, + { + "input": "&lhblk", + "description": "Bad named entity: lhblk without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&lhblk" + ] + ] + }, + { + "input": "▄", + "description": "Named entity: lhblk; with a semi-colon", + "output": [ + [ + "Character", + "\u2584" + ] + ] + }, + { + "input": "&ljcy", + "description": "Bad named entity: ljcy without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&ljcy" + ] + ] + }, + { + "input": "љ", + "description": "Named entity: ljcy; with a semi-colon", + "output": [ + [ + "Character", + "\u0459" + ] + ] + }, + { + "input": "&ll", + "description": "Bad named entity: ll without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&ll" + ] + ] + }, + { + "input": "≪", + "description": "Named entity: ll; with a semi-colon", + "output": [ + [ + "Character", + "\u226a" + ] + ] + }, + { + "input": "&llarr", + "description": "Bad named entity: llarr without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&llarr" + ] + ] + }, + { + "input": "⇇", + "description": "Named entity: llarr; with a semi-colon", + "output": [ + [ + "Character", + "\u21c7" + ] + ] + }, + { + "input": "&llcorner", + "description": "Bad named entity: llcorner without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&llcorner" + ] + ] + }, + { + "input": "⌞", + "description": "Named entity: llcorner; with a semi-colon", + "output": [ + [ + "Character", + "\u231e" + ] + ] + }, + { + "input": "&llhard", + "description": "Bad named entity: llhard without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&llhard" + ] + ] + }, + { + "input": "⥫", + "description": "Named entity: llhard; with a semi-colon", + "output": [ + [ + "Character", + "\u296b" + ] + ] + }, + { + "input": "&lltri", + "description": "Bad named entity: lltri without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&lltri" + ] + ] + }, + { + "input": "◺", + "description": "Named entity: lltri; with a semi-colon", + "output": [ + [ + "Character", + "\u25fa" + ] + ] + }, + { + "input": "&lmidot", + "description": "Bad named entity: lmidot without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&lmidot" + ] + ] + }, + { + "input": "ŀ", + "description": "Named entity: lmidot; with a semi-colon", + "output": [ + [ + "Character", + "\u0140" + ] + ] + }, + { + "input": "&lmoust", + "description": "Bad named entity: lmoust without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&lmoust" + ] + ] + }, + { + "input": "⎰", + "description": "Named entity: lmoust; with a semi-colon", + "output": [ + [ + "Character", + "\u23b0" + ] + ] + }, + { + "input": "&lmoustache", + "description": "Bad named entity: lmoustache without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&lmoustache" + ] + ] + }, + { + "input": "⎰", + "description": "Named entity: lmoustache; with a semi-colon", + "output": [ + [ + "Character", + "\u23b0" + ] + ] + }, + { + "input": "&lnE", + "description": "Bad named entity: lnE without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&lnE" + ] + ] + }, + { + "input": "≨", + "description": "Named entity: lnE; with a semi-colon", + "output": [ + [ + "Character", + "\u2268" + ] + ] + }, + { + "input": "&lnap", + "description": "Bad named entity: lnap without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&lnap" + ] + ] + }, + { + "input": "⪉", + "description": "Named entity: lnap; with a semi-colon", + "output": [ + [ + "Character", + "\u2a89" + ] + ] + }, + { + "input": "&lnapprox", + "description": "Bad named entity: lnapprox without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&lnapprox" + ] + ] + }, + { + "input": "⪉", + "description": "Named entity: lnapprox; with a semi-colon", + "output": [ + [ + "Character", + "\u2a89" + ] + ] + }, + { + "input": "&lne", + "description": "Bad named entity: lne without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&lne" + ] + ] + }, + { + "input": "⪇", + "description": "Named entity: lne; with a semi-colon", + "output": [ + [ + "Character", + "\u2a87" + ] + ] + }, + { + "input": "&lneq", + "description": "Bad named entity: lneq without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&lneq" + ] + ] + }, + { + "input": "⪇", + "description": "Named entity: lneq; with a semi-colon", + "output": [ + [ + "Character", + "\u2a87" + ] + ] + }, + { + "input": "&lneqq", + "description": "Bad named entity: lneqq without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&lneqq" + ] + ] + }, + { + "input": "≨", + "description": "Named entity: lneqq; with a semi-colon", + "output": [ + [ + "Character", + "\u2268" + ] + ] + }, + { + "input": "&lnsim", + "description": "Bad named entity: lnsim without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&lnsim" + ] + ] + }, + { + "input": "⋦", + "description": "Named entity: lnsim; with a semi-colon", + "output": [ + [ + "Character", + "\u22e6" + ] + ] + }, + { + "input": "&loang", + "description": "Bad named entity: loang without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&loang" + ] + ] + }, + { + "input": "⟬", + "description": "Named entity: loang; with a semi-colon", + "output": [ + [ + "Character", + "\u27ec" + ] + ] + }, + { + "input": "&loarr", + "description": "Bad named entity: loarr without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&loarr" + ] + ] + }, + { + "input": "⇽", + "description": "Named entity: loarr; with a semi-colon", + "output": [ + [ + "Character", + "\u21fd" + ] + ] + }, + { + "input": "&lobrk", + "description": "Bad named entity: lobrk without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&lobrk" + ] + ] + }, + { + "input": "⟦", + "description": "Named entity: lobrk; with a semi-colon", + "output": [ + [ + "Character", + "\u27e6" + ] + ] + }, + { + "input": "&longleftarrow", + "description": "Bad named entity: longleftarrow without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&longleftarrow" + ] + ] + }, + { + "input": "⟵", + "description": "Named entity: longleftarrow; with a semi-colon", + "output": [ + [ + "Character", + "\u27f5" + ] + ] + }, + { + "input": "&longleftrightarrow", + "description": "Bad named entity: longleftrightarrow without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&longleftrightarrow" + ] + ] + }, + { + "input": "⟷", + "description": "Named entity: longleftrightarrow; with a semi-colon", + "output": [ + [ + "Character", + "\u27f7" + ] + ] + }, + { + "input": "&longmapsto", + "description": "Bad named entity: longmapsto without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&longmapsto" + ] + ] + }, + { + "input": "⟼", + "description": "Named entity: longmapsto; with a semi-colon", + "output": [ + [ + "Character", + "\u27fc" + ] + ] + }, + { + "input": "&longrightarrow", + "description": "Bad named entity: longrightarrow without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&longrightarrow" + ] + ] + }, + { + "input": "⟶", + "description": "Named entity: longrightarrow; with a semi-colon", + "output": [ + [ + "Character", + "\u27f6" + ] + ] + }, + { + "input": "&looparrowleft", + "description": "Bad named entity: looparrowleft without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&looparrowleft" + ] + ] + }, + { + "input": "↫", + "description": "Named entity: looparrowleft; with a semi-colon", + "output": [ + [ + "Character", + "\u21ab" + ] + ] + }, + { + "input": "&looparrowright", + "description": "Bad named entity: looparrowright without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&looparrowright" + ] + ] + }, + { + "input": "↬", + "description": "Named entity: looparrowright; with a semi-colon", + "output": [ + [ + "Character", + "\u21ac" + ] + ] + }, + { + "input": "&lopar", + "description": "Bad named entity: lopar without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&lopar" + ] + ] + }, + { + "input": "⦅", + "description": "Named entity: lopar; with a semi-colon", + "output": [ + [ + "Character", + "\u2985" + ] + ] + }, + { + "input": "&lopf", + "description": "Bad named entity: lopf without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&lopf" + ] + ] + }, + { + "input": "𝕝", + "description": "Named entity: lopf; with a semi-colon", + "output": [ + [ + "Character", + "\ud835\udd5d" + ] + ] + }, + { + "input": "&loplus", + "description": "Bad named entity: loplus without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&loplus" + ] + ] + }, + { + "input": "⨭", + "description": "Named entity: loplus; with a semi-colon", + "output": [ + [ + "Character", + "\u2a2d" + ] + ] + }, + { + "input": "&lotimes", + "description": "Bad named entity: lotimes without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&lotimes" + ] + ] + }, + { + "input": "⨴", + "description": "Named entity: lotimes; with a semi-colon", + "output": [ + [ + "Character", + "\u2a34" + ] + ] + }, + { + "input": "&lowast", + "description": "Bad named entity: lowast without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&lowast" + ] + ] + }, + { + "input": "∗", + "description": "Named entity: lowast; with a semi-colon", + "output": [ + [ + "Character", + "\u2217" + ] + ] + }, + { + "input": "&lowbar", + "description": "Bad named entity: lowbar without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&lowbar" + ] + ] + }, + { + "input": "_", + "description": "Named entity: lowbar; with a semi-colon", + "output": [ + [ + "Character", + "_" + ] + ] + }, + { + "input": "&loz", + "description": "Bad named entity: loz without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&loz" + ] + ] + }, + { + "input": "◊", + "description": "Named entity: loz; with a semi-colon", + "output": [ + [ + "Character", + "\u25ca" + ] + ] + }, + { + "input": "&lozenge", + "description": "Bad named entity: lozenge without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&lozenge" + ] + ] + }, + { + "input": "◊", + "description": "Named entity: lozenge; with a semi-colon", + "output": [ + [ + "Character", + "\u25ca" + ] + ] + }, + { + "input": "&lozf", + "description": "Bad named entity: lozf without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&lozf" + ] + ] + }, + { + "input": "⧫", + "description": "Named entity: lozf; with a semi-colon", + "output": [ + [ + "Character", + "\u29eb" + ] + ] + }, + { + "input": "&lpar", + "description": "Bad named entity: lpar without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&lpar" + ] + ] + }, + { + "input": "(", + "description": "Named entity: lpar; with a semi-colon", + "output": [ + [ + "Character", + "(" + ] + ] + }, + { + "input": "&lparlt", + "description": "Bad named entity: lparlt without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&lparlt" + ] + ] + }, + { + "input": "⦓", + "description": "Named entity: lparlt; with a semi-colon", + "output": [ + [ + "Character", + "\u2993" + ] + ] + }, + { + "input": "&lrarr", + "description": "Bad named entity: lrarr without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&lrarr" + ] + ] + }, + { + "input": "⇆", + "description": "Named entity: lrarr; with a semi-colon", + "output": [ + [ + "Character", + "\u21c6" + ] + ] + }, + { + "input": "&lrcorner", + "description": "Bad named entity: lrcorner without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&lrcorner" + ] + ] + }, + { + "input": "⌟", + "description": "Named entity: lrcorner; with a semi-colon", + "output": [ + [ + "Character", + "\u231f" + ] + ] + }, + { + "input": "&lrhar", + "description": "Bad named entity: lrhar without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&lrhar" + ] + ] + }, + { + "input": "⇋", + "description": "Named entity: lrhar; with a semi-colon", + "output": [ + [ + "Character", + "\u21cb" + ] + ] + }, + { + "input": "&lrhard", + "description": "Bad named entity: lrhard without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&lrhard" + ] + ] + }, + { + "input": "⥭", + "description": "Named entity: lrhard; with a semi-colon", + "output": [ + [ + "Character", + "\u296d" + ] + ] + }, + { + "input": "&lrm", + "description": "Bad named entity: lrm without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&lrm" + ] + ] + }, + { + "input": "‎", + "description": "Named entity: lrm; with a semi-colon", + "output": [ + [ + "Character", + "\u200e" + ] + ] + }, + { + "input": "&lrtri", + "description": "Bad named entity: lrtri without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&lrtri" + ] + ] + }, + { + "input": "⊿", + "description": "Named entity: lrtri; with a semi-colon", + "output": [ + [ + "Character", + "\u22bf" + ] + ] + }, + { + "input": "&lsaquo", + "description": "Bad named entity: lsaquo without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&lsaquo" + ] + ] + }, + { + "input": "‹", + "description": "Named entity: lsaquo; with a semi-colon", + "output": [ + [ + "Character", + "\u2039" + ] + ] + }, + { + "input": "&lscr", + "description": "Bad named entity: lscr without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&lscr" + ] + ] + }, + { + "input": "𝓁", + "description": "Named entity: lscr; with a semi-colon", + "output": [ + [ + "Character", + "\ud835\udcc1" + ] + ] + }, + { + "input": "&lsh", + "description": "Bad named entity: lsh without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&lsh" + ] + ] + }, + { + "input": "↰", + "description": "Named entity: lsh; with a semi-colon", + "output": [ + [ + "Character", + "\u21b0" + ] + ] + }, + { + "input": "&lsim", + "description": "Bad named entity: lsim without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&lsim" + ] + ] + }, + { + "input": "≲", + "description": "Named entity: lsim; with a semi-colon", + "output": [ + [ + "Character", + "\u2272" + ] + ] + }, + { + "input": "&lsime", + "description": "Bad named entity: lsime without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&lsime" + ] + ] + }, + { + "input": "⪍", + "description": "Named entity: lsime; with a semi-colon", + "output": [ + [ + "Character", + "\u2a8d" + ] + ] + }, + { + "input": "&lsimg", + "description": "Bad named entity: lsimg without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&lsimg" + ] + ] + }, + { + "input": "⪏", + "description": "Named entity: lsimg; with a semi-colon", + "output": [ + [ + "Character", + "\u2a8f" + ] + ] + }, + { + "input": "&lsqb", + "description": "Bad named entity: lsqb without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&lsqb" + ] + ] + }, + { + "input": "[", + "description": "Named entity: lsqb; with a semi-colon", + "output": [ + [ + "Character", + "[" + ] + ] + }, + { + "input": "&lsquo", + "description": "Bad named entity: lsquo without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&lsquo" + ] + ] + }, + { + "input": "‘", + "description": "Named entity: lsquo; with a semi-colon", + "output": [ + [ + "Character", + "\u2018" + ] + ] + }, + { + "input": "&lsquor", + "description": "Bad named entity: lsquor without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&lsquor" + ] + ] + }, + { + "input": "‚", + "description": "Named entity: lsquor; with a semi-colon", + "output": [ + [ + "Character", + "\u201a" + ] + ] + }, + { + "input": "&lstrok", + "description": "Bad named entity: lstrok without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&lstrok" + ] + ] + }, + { + "input": "ł", + "description": "Named entity: lstrok; with a semi-colon", + "output": [ + [ + "Character", + "\u0142" + ] + ] + }, + { + "input": "<", + "description": "Named entity: lt without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "<" + ] + ] + }, + { + "input": "<", + "description": "Named entity: lt; with a semi-colon", + "output": [ + [ + "Character", + "<" + ] + ] + }, + { + "input": "⪦", + "description": "Named entity: ltcc; with a semi-colon", + "output": [ + [ + "Character", + "\u2aa6" + ] + ] + }, + { + "input": "⩹", + "description": "Named entity: ltcir; with a semi-colon", + "output": [ + [ + "Character", + "\u2a79" + ] + ] + }, + { + "input": "⋖", + "description": "Named entity: ltdot; with a semi-colon", + "output": [ + [ + "Character", + "\u22d6" + ] + ] + }, + { + "input": "⋋", + "description": "Named entity: lthree; with a semi-colon", + "output": [ + [ + "Character", + "\u22cb" + ] + ] + }, + { + "input": "⋉", + "description": "Named entity: ltimes; with a semi-colon", + "output": [ + [ + "Character", + "\u22c9" + ] + ] + }, + { + "input": "⥶", + "description": "Named entity: ltlarr; with a semi-colon", + "output": [ + [ + "Character", + "\u2976" + ] + ] + }, + { + "input": "⩻", + "description": "Named entity: ltquest; with a semi-colon", + "output": [ + [ + "Character", + "\u2a7b" + ] + ] + }, + { + "input": "⦖", + "description": "Named entity: ltrPar; with a semi-colon", + "output": [ + [ + "Character", + "\u2996" + ] + ] + }, + { + "input": "◃", + "description": "Named entity: ltri; with a semi-colon", + "output": [ + [ + "Character", + "\u25c3" + ] + ] + }, + { + "input": "⊴", + "description": "Named entity: ltrie; with a semi-colon", + "output": [ + [ + "Character", + "\u22b4" + ] + ] + }, + { + "input": "◂", + "description": "Named entity: ltrif; with a semi-colon", + "output": [ + [ + "Character", + "\u25c2" + ] + ] + }, + { + "input": "&lurdshar", + "description": "Bad named entity: lurdshar without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&lurdshar" + ] + ] + }, + { + "input": "⥊", + "description": "Named entity: lurdshar; with a semi-colon", + "output": [ + [ + "Character", + "\u294a" + ] + ] + }, + { + "input": "&luruhar", + "description": "Bad named entity: luruhar without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&luruhar" + ] + ] + }, + { + "input": "⥦", + "description": "Named entity: luruhar; with a semi-colon", + "output": [ + [ + "Character", + "\u2966" + ] + ] + }, + { + "input": "&lvertneqq", + "description": "Bad named entity: lvertneqq without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&lvertneqq" + ] + ] + }, + { + "input": "≨︀", + "description": "Named entity: lvertneqq; with a semi-colon", + "output": [ + [ + "Character", + "\u2268\ufe00" + ] + ] + }, + { + "input": "&lvnE", + "description": "Bad named entity: lvnE without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&lvnE" + ] + ] + }, + { + "input": "≨︀", + "description": "Named entity: lvnE; with a semi-colon", + "output": [ + [ + "Character", + "\u2268\ufe00" + ] + ] + }, + { + "input": "&mDDot", + "description": "Bad named entity: mDDot without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&mDDot" + ] + ] + }, + { + "input": "∺", + "description": "Named entity: mDDot; with a semi-colon", + "output": [ + [ + "Character", + "\u223a" + ] + ] + }, + { + "input": "¯", + "description": "Named entity: macr without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "\u00af" + ] + ] + }, + { + "input": "¯", + "description": "Named entity: macr; with a semi-colon", + "output": [ + [ + "Character", + "\u00af" + ] + ] + }, + { + "input": "&male", + "description": "Bad named entity: male without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&male" + ] + ] + }, + { + "input": "♂", + "description": "Named entity: male; with a semi-colon", + "output": [ + [ + "Character", + "\u2642" + ] + ] + }, + { + "input": "&malt", + "description": "Bad named entity: malt without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&malt" + ] + ] + }, + { + "input": "✠", + "description": "Named entity: malt; with a semi-colon", + "output": [ + [ + "Character", + "\u2720" + ] + ] + }, + { + "input": "&maltese", + "description": "Bad named entity: maltese without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&maltese" + ] + ] + }, + { + "input": "✠", + "description": "Named entity: maltese; with a semi-colon", + "output": [ + [ + "Character", + "\u2720" + ] + ] + }, + { + "input": "&map", + "description": "Bad named entity: map without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&map" + ] + ] + }, + { + "input": "↦", + "description": "Named entity: map; with a semi-colon", + "output": [ + [ + "Character", + "\u21a6" + ] + ] + }, + { + "input": "&mapsto", + "description": "Bad named entity: mapsto without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&mapsto" + ] + ] + }, + { + "input": "↦", + "description": "Named entity: mapsto; with a semi-colon", + "output": [ + [ + "Character", + "\u21a6" + ] + ] + }, + { + "input": "&mapstodown", + "description": "Bad named entity: mapstodown without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&mapstodown" + ] + ] + }, + { + "input": "↧", + "description": "Named entity: mapstodown; with a semi-colon", + "output": [ + [ + "Character", + "\u21a7" + ] + ] + }, + { + "input": "&mapstoleft", + "description": "Bad named entity: mapstoleft without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&mapstoleft" + ] + ] + }, + { + "input": "↤", + "description": "Named entity: mapstoleft; with a semi-colon", + "output": [ + [ + "Character", + "\u21a4" + ] + ] + }, + { + "input": "&mapstoup", + "description": "Bad named entity: mapstoup without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&mapstoup" + ] + ] + }, + { + "input": "↥", + "description": "Named entity: mapstoup; with a semi-colon", + "output": [ + [ + "Character", + "\u21a5" + ] + ] + }, + { + "input": "&marker", + "description": "Bad named entity: marker without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&marker" + ] + ] + }, + { + "input": "▮", + "description": "Named entity: marker; with a semi-colon", + "output": [ + [ + "Character", + "\u25ae" + ] + ] + }, + { + "input": "&mcomma", + "description": "Bad named entity: mcomma without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&mcomma" + ] + ] + }, + { + "input": "⨩", + "description": "Named entity: mcomma; with a semi-colon", + "output": [ + [ + "Character", + "\u2a29" + ] + ] + }, + { + "input": "&mcy", + "description": "Bad named entity: mcy without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&mcy" + ] + ] + }, + { + "input": "м", + "description": "Named entity: mcy; with a semi-colon", + "output": [ + [ + "Character", + "\u043c" + ] + ] + }, + { + "input": "&mdash", + "description": "Bad named entity: mdash without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&mdash" + ] + ] + }, + { + "input": "—", + "description": "Named entity: mdash; with a semi-colon", + "output": [ + [ + "Character", + "\u2014" + ] + ] + }, + { + "input": "&measuredangle", + "description": "Bad named entity: measuredangle without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&measuredangle" + ] + ] + }, + { + "input": "∡", + "description": "Named entity: measuredangle; with a semi-colon", + "output": [ + [ + "Character", + "\u2221" + ] + ] + }, + { + "input": "&mfr", + "description": "Bad named entity: mfr without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&mfr" + ] + ] + }, + { + "input": "𝔪", + "description": "Named entity: mfr; with a semi-colon", + "output": [ + [ + "Character", + "\ud835\udd2a" + ] + ] + }, + { + "input": "&mho", + "description": "Bad named entity: mho without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&mho" + ] + ] + }, + { + "input": "℧", + "description": "Named entity: mho; with a semi-colon", + "output": [ + [ + "Character", + "\u2127" + ] + ] + }, + { + "input": "µ", + "description": "Named entity: micro without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "\u00b5" + ] + ] + }, + { + "input": "µ", + "description": "Named entity: micro; with a semi-colon", + "output": [ + [ + "Character", + "\u00b5" + ] + ] + }, + { + "input": "&mid", + "description": "Bad named entity: mid without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&mid" + ] + ] + }, + { + "input": "∣", + "description": "Named entity: mid; with a semi-colon", + "output": [ + [ + "Character", + "\u2223" + ] + ] + }, + { + "input": "&midast", + "description": "Bad named entity: midast without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&midast" + ] + ] + }, + { + "input": "*", + "description": "Named entity: midast; with a semi-colon", + "output": [ + [ + "Character", + "*" + ] + ] + }, + { + "input": "&midcir", + "description": "Bad named entity: midcir without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&midcir" + ] + ] + }, + { + "input": "⫰", + "description": "Named entity: midcir; with a semi-colon", + "output": [ + [ + "Character", + "\u2af0" + ] + ] + }, + { + "input": "·", + "description": "Named entity: middot without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "\u00b7" + ] + ] + }, + { + "input": "·", + "description": "Named entity: middot; with a semi-colon", + "output": [ + [ + "Character", + "\u00b7" + ] + ] + }, + { + "input": "&minus", + "description": "Bad named entity: minus without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&minus" + ] + ] + }, + { + "input": "−", + "description": "Named entity: minus; with a semi-colon", + "output": [ + [ + "Character", + "\u2212" + ] + ] + }, + { + "input": "&minusb", + "description": "Bad named entity: minusb without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&minusb" + ] + ] + }, + { + "input": "⊟", + "description": "Named entity: minusb; with a semi-colon", + "output": [ + [ + "Character", + "\u229f" + ] + ] + }, + { + "input": "&minusd", + "description": "Bad named entity: minusd without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&minusd" + ] + ] + }, + { + "input": "∸", + "description": "Named entity: minusd; with a semi-colon", + "output": [ + [ + "Character", + "\u2238" + ] + ] + }, + { + "input": "&minusdu", + "description": "Bad named entity: minusdu without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&minusdu" + ] + ] + }, + { + "input": "⨪", + "description": "Named entity: minusdu; with a semi-colon", + "output": [ + [ + "Character", + "\u2a2a" + ] + ] + }, + { + "input": "&mlcp", + "description": "Bad named entity: mlcp without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&mlcp" + ] + ] + }, + { + "input": "⫛", + "description": "Named entity: mlcp; with a semi-colon", + "output": [ + [ + "Character", + "\u2adb" + ] + ] + }, + { + "input": "&mldr", + "description": "Bad named entity: mldr without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&mldr" + ] + ] + }, + { + "input": "…", + "description": "Named entity: mldr; with a semi-colon", + "output": [ + [ + "Character", + "\u2026" + ] + ] + }, + { + "input": "&mnplus", + "description": "Bad named entity: mnplus without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&mnplus" + ] + ] + }, + { + "input": "∓", + "description": "Named entity: mnplus; with a semi-colon", + "output": [ + [ + "Character", + "\u2213" + ] + ] + }, + { + "input": "&models", + "description": "Bad named entity: models without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&models" + ] + ] + }, + { + "input": "⊧", + "description": "Named entity: models; with a semi-colon", + "output": [ + [ + "Character", + "\u22a7" + ] + ] + }, + { + "input": "&mopf", + "description": "Bad named entity: mopf without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&mopf" + ] + ] + }, + { + "input": "𝕞", + "description": "Named entity: mopf; with a semi-colon", + "output": [ + [ + "Character", + "\ud835\udd5e" + ] + ] + }, + { + "input": "&mp", + "description": "Bad named entity: mp without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&mp" + ] + ] + }, + { + "input": "∓", + "description": "Named entity: mp; with a semi-colon", + "output": [ + [ + "Character", + "\u2213" + ] + ] + }, + { + "input": "&mscr", + "description": "Bad named entity: mscr without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&mscr" + ] + ] + }, + { + "input": "𝓂", + "description": "Named entity: mscr; with a semi-colon", + "output": [ + [ + "Character", + "\ud835\udcc2" + ] + ] + }, + { + "input": "&mstpos", + "description": "Bad named entity: mstpos without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&mstpos" + ] + ] + }, + { + "input": "∾", + "description": "Named entity: mstpos; with a semi-colon", + "output": [ + [ + "Character", + "\u223e" + ] + ] + }, + { + "input": "&mu", + "description": "Bad named entity: mu without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&mu" + ] + ] + }, + { + "input": "μ", + "description": "Named entity: mu; with a semi-colon", + "output": [ + [ + "Character", + "\u03bc" + ] + ] + }, + { + "input": "&multimap", + "description": "Bad named entity: multimap without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&multimap" + ] + ] + }, + { + "input": "⊸", + "description": "Named entity: multimap; with a semi-colon", + "output": [ + [ + "Character", + "\u22b8" + ] + ] + }, + { + "input": "&mumap", + "description": "Bad named entity: mumap without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&mumap" + ] + ] + }, + { + "input": "⊸", + "description": "Named entity: mumap; with a semi-colon", + "output": [ + [ + "Character", + "\u22b8" + ] + ] + }, + { + "input": "&nGg", + "description": "Bad named entity: nGg without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&nGg" + ] + ] + }, + { + "input": "⋙̸", + "description": "Named entity: nGg; with a semi-colon", + "output": [ + [ + "Character", + "\u22d9\u0338" + ] + ] + }, + { + "input": "&nGt", + "description": "Bad named entity: nGt without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&nGt" + ] + ] + }, + { + "input": "≫⃒", + "description": "Named entity: nGt; with a semi-colon", + "output": [ + [ + "Character", + "\u226b\u20d2" + ] + ] + }, + { + "input": "&nGtv", + "description": "Bad named entity: nGtv without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&nGtv" + ] + ] + }, + { + "input": "≫̸", + "description": "Named entity: nGtv; with a semi-colon", + "output": [ + [ + "Character", + "\u226b\u0338" + ] + ] + }, + { + "input": "&nLeftarrow", + "description": "Bad named entity: nLeftarrow without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&nLeftarrow" + ] + ] + }, + { + "input": "⇍", + "description": "Named entity: nLeftarrow; with a semi-colon", + "output": [ + [ + "Character", + "\u21cd" + ] + ] + }, + { + "input": "&nLeftrightarrow", + "description": "Bad named entity: nLeftrightarrow without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&nLeftrightarrow" + ] + ] + }, + { + "input": "⇎", + "description": "Named entity: nLeftrightarrow; with a semi-colon", + "output": [ + [ + "Character", + "\u21ce" + ] + ] + }, + { + "input": "&nLl", + "description": "Bad named entity: nLl without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&nLl" + ] + ] + }, + { + "input": "⋘̸", + "description": "Named entity: nLl; with a semi-colon", + "output": [ + [ + "Character", + "\u22d8\u0338" + ] + ] + }, + { + "input": "&nLt", + "description": "Bad named entity: nLt without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&nLt" + ] + ] + }, + { + "input": "≪⃒", + "description": "Named entity: nLt; with a semi-colon", + "output": [ + [ + "Character", + "\u226a\u20d2" + ] + ] + }, + { + "input": "&nLtv", + "description": "Bad named entity: nLtv without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&nLtv" + ] + ] + }, + { + "input": "≪̸", + "description": "Named entity: nLtv; with a semi-colon", + "output": [ + [ + "Character", + "\u226a\u0338" + ] + ] + }, + { + "input": "&nRightarrow", + "description": "Bad named entity: nRightarrow without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&nRightarrow" + ] + ] + }, + { + "input": "⇏", + "description": "Named entity: nRightarrow; with a semi-colon", + "output": [ + [ + "Character", + "\u21cf" + ] + ] + }, + { + "input": "&nVDash", + "description": "Bad named entity: nVDash without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&nVDash" + ] + ] + }, + { + "input": "⊯", + "description": "Named entity: nVDash; with a semi-colon", + "output": [ + [ + "Character", + "\u22af" + ] + ] + }, + { + "input": "&nVdash", + "description": "Bad named entity: nVdash without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&nVdash" + ] + ] + }, + { + "input": "⊮", + "description": "Named entity: nVdash; with a semi-colon", + "output": [ + [ + "Character", + "\u22ae" + ] + ] + }, + { + "input": "&nabla", + "description": "Bad named entity: nabla without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&nabla" + ] + ] + }, + { + "input": "∇", + "description": "Named entity: nabla; with a semi-colon", + "output": [ + [ + "Character", + "\u2207" + ] + ] + }, + { + "input": "&nacute", + "description": "Bad named entity: nacute without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&nacute" + ] + ] + }, + { + "input": "ń", + "description": "Named entity: nacute; with a semi-colon", + "output": [ + [ + "Character", + "\u0144" + ] + ] + }, + { + "input": "&nang", + "description": "Bad named entity: nang without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&nang" + ] + ] + }, + { + "input": "∠⃒", + "description": "Named entity: nang; with a semi-colon", + "output": [ + [ + "Character", + "\u2220\u20d2" + ] + ] + }, + { + "input": "&nap", + "description": "Bad named entity: nap without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&nap" + ] + ] + }, + { + "input": "≉", + "description": "Named entity: nap; with a semi-colon", + "output": [ + [ + "Character", + "\u2249" + ] + ] + }, + { + "input": "&napE", + "description": "Bad named entity: napE without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&napE" + ] + ] + }, + { + "input": "⩰̸", + "description": "Named entity: napE; with a semi-colon", + "output": [ + [ + "Character", + "\u2a70\u0338" + ] + ] + }, + { + "input": "&napid", + "description": "Bad named entity: napid without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&napid" + ] + ] + }, + { + "input": "≋̸", + "description": "Named entity: napid; with a semi-colon", + "output": [ + [ + "Character", + "\u224b\u0338" + ] + ] + }, + { + "input": "&napos", + "description": "Bad named entity: napos without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&napos" + ] + ] + }, + { + "input": "ʼn", + "description": "Named entity: napos; with a semi-colon", + "output": [ + [ + "Character", + "\u0149" + ] + ] + }, + { + "input": "&napprox", + "description": "Bad named entity: napprox without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&napprox" + ] + ] + }, + { + "input": "≉", + "description": "Named entity: napprox; with a semi-colon", + "output": [ + [ + "Character", + "\u2249" + ] + ] + }, + { + "input": "&natur", + "description": "Bad named entity: natur without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&natur" + ] + ] + }, + { + "input": "♮", + "description": "Named entity: natur; with a semi-colon", + "output": [ + [ + "Character", + "\u266e" + ] + ] + }, + { + "input": "&natural", + "description": "Bad named entity: natural without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&natural" + ] + ] + }, + { + "input": "♮", + "description": "Named entity: natural; with a semi-colon", + "output": [ + [ + "Character", + "\u266e" + ] + ] + }, + { + "input": "&naturals", + "description": "Bad named entity: naturals without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&naturals" + ] + ] + }, + { + "input": "ℕ", + "description": "Named entity: naturals; with a semi-colon", + "output": [ + [ + "Character", + "\u2115" + ] + ] + }, + { + "input": " ", + "description": "Named entity: nbsp without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "\u00a0" + ] + ] + }, + { + "input": " ", + "description": "Named entity: nbsp; with a semi-colon", + "output": [ + [ + "Character", + "\u00a0" + ] + ] + }, + { + "input": "&nbump", + "description": "Bad named entity: nbump without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&nbump" + ] + ] + }, + { + "input": "≎̸", + "description": "Named entity: nbump; with a semi-colon", + "output": [ + [ + "Character", + "\u224e\u0338" + ] + ] + }, + { + "input": "&nbumpe", + "description": "Bad named entity: nbumpe without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&nbumpe" + ] + ] + }, + { + "input": "≏̸", + "description": "Named entity: nbumpe; with a semi-colon", + "output": [ + [ + "Character", + "\u224f\u0338" + ] + ] + }, + { + "input": "&ncap", + "description": "Bad named entity: ncap without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&ncap" + ] + ] + }, + { + "input": "⩃", + "description": "Named entity: ncap; with a semi-colon", + "output": [ + [ + "Character", + "\u2a43" + ] + ] + }, + { + "input": "&ncaron", + "description": "Bad named entity: ncaron without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&ncaron" + ] + ] + }, + { + "input": "ň", + "description": "Named entity: ncaron; with a semi-colon", + "output": [ + [ + "Character", + "\u0148" + ] + ] + }, + { + "input": "&ncedil", + "description": "Bad named entity: ncedil without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&ncedil" + ] + ] + }, + { + "input": "ņ", + "description": "Named entity: ncedil; with a semi-colon", + "output": [ + [ + "Character", + "\u0146" + ] + ] + }, + { + "input": "&ncong", + "description": "Bad named entity: ncong without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&ncong" + ] + ] + }, + { + "input": "≇", + "description": "Named entity: ncong; with a semi-colon", + "output": [ + [ + "Character", + "\u2247" + ] + ] + }, + { + "input": "&ncongdot", + "description": "Bad named entity: ncongdot without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&ncongdot" + ] + ] + }, + { + "input": "⩭̸", + "description": "Named entity: ncongdot; with a semi-colon", + "output": [ + [ + "Character", + "\u2a6d\u0338" + ] + ] + }, + { + "input": "&ncup", + "description": "Bad named entity: ncup without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&ncup" + ] + ] + }, + { + "input": "⩂", + "description": "Named entity: ncup; with a semi-colon", + "output": [ + [ + "Character", + "\u2a42" + ] + ] + }, + { + "input": "&ncy", + "description": "Bad named entity: ncy without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&ncy" + ] + ] + }, + { + "input": "н", + "description": "Named entity: ncy; with a semi-colon", + "output": [ + [ + "Character", + "\u043d" + ] + ] + }, + { + "input": "&ndash", + "description": "Bad named entity: ndash without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&ndash" + ] + ] + }, + { + "input": "–", + "description": "Named entity: ndash; with a semi-colon", + "output": [ + [ + "Character", + "\u2013" + ] + ] + }, + { + "input": "&ne", + "description": "Bad named entity: ne without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&ne" + ] + ] + }, + { + "input": "≠", + "description": "Named entity: ne; with a semi-colon", + "output": [ + [ + "Character", + "\u2260" + ] + ] + }, + { + "input": "&neArr", + "description": "Bad named entity: neArr without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&neArr" + ] + ] + }, + { + "input": "⇗", + "description": "Named entity: neArr; with a semi-colon", + "output": [ + [ + "Character", + "\u21d7" + ] + ] + }, + { + "input": "&nearhk", + "description": "Bad named entity: nearhk without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&nearhk" + ] + ] + }, + { + "input": "⤤", + "description": "Named entity: nearhk; with a semi-colon", + "output": [ + [ + "Character", + "\u2924" + ] + ] + }, + { + "input": "&nearr", + "description": "Bad named entity: nearr without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&nearr" + ] + ] + }, + { + "input": "↗", + "description": "Named entity: nearr; with a semi-colon", + "output": [ + [ + "Character", + "\u2197" + ] + ] + }, + { + "input": "&nearrow", + "description": "Bad named entity: nearrow without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&nearrow" + ] + ] + }, + { + "input": "↗", + "description": "Named entity: nearrow; with a semi-colon", + "output": [ + [ + "Character", + "\u2197" + ] + ] + }, + { + "input": "&nedot", + "description": "Bad named entity: nedot without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&nedot" + ] + ] + }, + { + "input": "≐̸", + "description": "Named entity: nedot; with a semi-colon", + "output": [ + [ + "Character", + "\u2250\u0338" + ] + ] + }, + { + "input": "&nequiv", + "description": "Bad named entity: nequiv without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&nequiv" + ] + ] + }, + { + "input": "≢", + "description": "Named entity: nequiv; with a semi-colon", + "output": [ + [ + "Character", + "\u2262" + ] + ] + }, + { + "input": "&nesear", + "description": "Bad named entity: nesear without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&nesear" + ] + ] + }, + { + "input": "⤨", + "description": "Named entity: nesear; with a semi-colon", + "output": [ + [ + "Character", + "\u2928" + ] + ] + }, + { + "input": "&nesim", + "description": "Bad named entity: nesim without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&nesim" + ] + ] + }, + { + "input": "≂̸", + "description": "Named entity: nesim; with a semi-colon", + "output": [ + [ + "Character", + "\u2242\u0338" + ] + ] + }, + { + "input": "&nexist", + "description": "Bad named entity: nexist without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&nexist" + ] + ] + }, + { + "input": "∄", + "description": "Named entity: nexist; with a semi-colon", + "output": [ + [ + "Character", + "\u2204" + ] + ] + }, + { + "input": "&nexists", + "description": "Bad named entity: nexists without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&nexists" + ] + ] + }, + { + "input": "∄", + "description": "Named entity: nexists; with a semi-colon", + "output": [ + [ + "Character", + "\u2204" + ] + ] + }, + { + "input": "&nfr", + "description": "Bad named entity: nfr without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&nfr" + ] + ] + }, + { + "input": "𝔫", + "description": "Named entity: nfr; with a semi-colon", + "output": [ + [ + "Character", + "\ud835\udd2b" + ] + ] + }, + { + "input": "&ngE", + "description": "Bad named entity: ngE without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&ngE" + ] + ] + }, + { + "input": "≧̸", + "description": "Named entity: ngE; with a semi-colon", + "output": [ + [ + "Character", + "\u2267\u0338" + ] + ] + }, + { + "input": "&nge", + "description": "Bad named entity: nge without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&nge" + ] + ] + }, + { + "input": "≱", + "description": "Named entity: nge; with a semi-colon", + "output": [ + [ + "Character", + "\u2271" + ] + ] + }, + { + "input": "&ngeq", + "description": "Bad named entity: ngeq without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&ngeq" + ] + ] + }, + { + "input": "≱", + "description": "Named entity: ngeq; with a semi-colon", + "output": [ + [ + "Character", + "\u2271" + ] + ] + }, + { + "input": "&ngeqq", + "description": "Bad named entity: ngeqq without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&ngeqq" + ] + ] + }, + { + "input": "≧̸", + "description": "Named entity: ngeqq; with a semi-colon", + "output": [ + [ + "Character", + "\u2267\u0338" + ] + ] + }, + { + "input": "&ngeqslant", + "description": "Bad named entity: ngeqslant without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&ngeqslant" + ] + ] + }, + { + "input": "⩾̸", + "description": "Named entity: ngeqslant; with a semi-colon", + "output": [ + [ + "Character", + "\u2a7e\u0338" + ] + ] + }, + { + "input": "&nges", + "description": "Bad named entity: nges without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&nges" + ] + ] + }, + { + "input": "⩾̸", + "description": "Named entity: nges; with a semi-colon", + "output": [ + [ + "Character", + "\u2a7e\u0338" + ] + ] + }, + { + "input": "&ngsim", + "description": "Bad named entity: ngsim without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&ngsim" + ] + ] + }, + { + "input": "≵", + "description": "Named entity: ngsim; with a semi-colon", + "output": [ + [ + "Character", + "\u2275" + ] + ] + }, + { + "input": "&ngt", + "description": "Bad named entity: ngt without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&ngt" + ] + ] + }, + { + "input": "≯", + "description": "Named entity: ngt; with a semi-colon", + "output": [ + [ + "Character", + "\u226f" + ] + ] + }, + { + "input": "&ngtr", + "description": "Bad named entity: ngtr without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&ngtr" + ] + ] + }, + { + "input": "≯", + "description": "Named entity: ngtr; with a semi-colon", + "output": [ + [ + "Character", + "\u226f" + ] + ] + }, + { + "input": "&nhArr", + "description": "Bad named entity: nhArr without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&nhArr" + ] + ] + }, + { + "input": "⇎", + "description": "Named entity: nhArr; with a semi-colon", + "output": [ + [ + "Character", + "\u21ce" + ] + ] + }, + { + "input": "&nharr", + "description": "Bad named entity: nharr without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&nharr" + ] + ] + }, + { + "input": "↮", + "description": "Named entity: nharr; with a semi-colon", + "output": [ + [ + "Character", + "\u21ae" + ] + ] + }, + { + "input": "&nhpar", + "description": "Bad named entity: nhpar without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&nhpar" + ] + ] + }, + { + "input": "⫲", + "description": "Named entity: nhpar; with a semi-colon", + "output": [ + [ + "Character", + "\u2af2" + ] + ] + }, + { + "input": "&ni", + "description": "Bad named entity: ni without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&ni" + ] + ] + }, + { + "input": "∋", + "description": "Named entity: ni; with a semi-colon", + "output": [ + [ + "Character", + "\u220b" + ] + ] + }, + { + "input": "&nis", + "description": "Bad named entity: nis without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&nis" + ] + ] + }, + { + "input": "⋼", + "description": "Named entity: nis; with a semi-colon", + "output": [ + [ + "Character", + "\u22fc" + ] + ] + }, + { + "input": "&nisd", + "description": "Bad named entity: nisd without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&nisd" + ] + ] + }, + { + "input": "⋺", + "description": "Named entity: nisd; with a semi-colon", + "output": [ + [ + "Character", + "\u22fa" + ] + ] + }, + { + "input": "&niv", + "description": "Bad named entity: niv without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&niv" + ] + ] + }, + { + "input": "∋", + "description": "Named entity: niv; with a semi-colon", + "output": [ + [ + "Character", + "\u220b" + ] + ] + }, + { + "input": "&njcy", + "description": "Bad named entity: njcy without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&njcy" + ] + ] + }, + { + "input": "њ", + "description": "Named entity: njcy; with a semi-colon", + "output": [ + [ + "Character", + "\u045a" + ] + ] + }, + { + "input": "&nlArr", + "description": "Bad named entity: nlArr without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&nlArr" + ] + ] + }, + { + "input": "⇍", + "description": "Named entity: nlArr; with a semi-colon", + "output": [ + [ + "Character", + "\u21cd" + ] + ] + }, + { + "input": "&nlE", + "description": "Bad named entity: nlE without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&nlE" + ] + ] + }, + { + "input": "≦̸", + "description": "Named entity: nlE; with a semi-colon", + "output": [ + [ + "Character", + "\u2266\u0338" + ] + ] + }, + { + "input": "&nlarr", + "description": "Bad named entity: nlarr without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&nlarr" + ] + ] + }, + { + "input": "↚", + "description": "Named entity: nlarr; with a semi-colon", + "output": [ + [ + "Character", + "\u219a" + ] + ] + }, + { + "input": "&nldr", + "description": "Bad named entity: nldr without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&nldr" + ] + ] + }, + { + "input": "‥", + "description": "Named entity: nldr; with a semi-colon", + "output": [ + [ + "Character", + "\u2025" + ] + ] + }, + { + "input": "&nle", + "description": "Bad named entity: nle without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&nle" + ] + ] + }, + { + "input": "≰", + "description": "Named entity: nle; with a semi-colon", + "output": [ + [ + "Character", + "\u2270" + ] + ] + }, + { + "input": "&nleftarrow", + "description": "Bad named entity: nleftarrow without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&nleftarrow" + ] + ] + }, + { + "input": "↚", + "description": "Named entity: nleftarrow; with a semi-colon", + "output": [ + [ + "Character", + "\u219a" + ] + ] + }, + { + "input": "&nleftrightarrow", + "description": "Bad named entity: nleftrightarrow without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&nleftrightarrow" + ] + ] + }, + { + "input": "↮", + "description": "Named entity: nleftrightarrow; with a semi-colon", + "output": [ + [ + "Character", + "\u21ae" + ] + ] + }, + { + "input": "&nleq", + "description": "Bad named entity: nleq without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&nleq" + ] + ] + }, + { + "input": "≰", + "description": "Named entity: nleq; with a semi-colon", + "output": [ + [ + "Character", + "\u2270" + ] + ] + }, + { + "input": "&nleqq", + "description": "Bad named entity: nleqq without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&nleqq" + ] + ] + }, + { + "input": "≦̸", + "description": "Named entity: nleqq; with a semi-colon", + "output": [ + [ + "Character", + "\u2266\u0338" + ] + ] + }, + { + "input": "&nleqslant", + "description": "Bad named entity: nleqslant without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&nleqslant" + ] + ] + }, + { + "input": "⩽̸", + "description": "Named entity: nleqslant; with a semi-colon", + "output": [ + [ + "Character", + "\u2a7d\u0338" + ] + ] + }, + { + "input": "&nles", + "description": "Bad named entity: nles without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&nles" + ] + ] + }, + { + "input": "⩽̸", + "description": "Named entity: nles; with a semi-colon", + "output": [ + [ + "Character", + "\u2a7d\u0338" + ] + ] + }, + { + "input": "&nless", + "description": "Bad named entity: nless without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&nless" + ] + ] + }, + { + "input": "≮", + "description": "Named entity: nless; with a semi-colon", + "output": [ + [ + "Character", + "\u226e" + ] + ] + }, + { + "input": "&nlsim", + "description": "Bad named entity: nlsim without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&nlsim" + ] + ] + }, + { + "input": "≴", + "description": "Named entity: nlsim; with a semi-colon", + "output": [ + [ + "Character", + "\u2274" + ] + ] + }, + { + "input": "&nlt", + "description": "Bad named entity: nlt without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&nlt" + ] + ] + }, + { + "input": "≮", + "description": "Named entity: nlt; with a semi-colon", + "output": [ + [ + "Character", + "\u226e" + ] + ] + }, + { + "input": "&nltri", + "description": "Bad named entity: nltri without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&nltri" + ] + ] + }, + { + "input": "⋪", + "description": "Named entity: nltri; with a semi-colon", + "output": [ + [ + "Character", + "\u22ea" + ] + ] + }, + { + "input": "&nltrie", + "description": "Bad named entity: nltrie without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&nltrie" + ] + ] + }, + { + "input": "⋬", + "description": "Named entity: nltrie; with a semi-colon", + "output": [ + [ + "Character", + "\u22ec" + ] + ] + }, + { + "input": "&nmid", + "description": "Bad named entity: nmid without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&nmid" + ] + ] + }, + { + "input": "∤", + "description": "Named entity: nmid; with a semi-colon", + "output": [ + [ + "Character", + "\u2224" + ] + ] + }, + { + "input": "&nopf", + "description": "Bad named entity: nopf without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&nopf" + ] + ] + }, + { + "input": "𝕟", + "description": "Named entity: nopf; with a semi-colon", + "output": [ + [ + "Character", + "\ud835\udd5f" + ] + ] + }, + { + "input": "¬", + "description": "Named entity: not without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "\u00ac" + ] + ] + }, + { + "input": "¬", + "description": "Named entity: not; with a semi-colon", + "output": [ + [ + "Character", + "\u00ac" + ] + ] + }, + { + "input": "∉", + "description": "Named entity: notin; with a semi-colon", + "output": [ + [ + "Character", + "\u2209" + ] + ] + }, + { + "input": "⋹̸", + "description": "Named entity: notinE; with a semi-colon", + "output": [ + [ + "Character", + "\u22f9\u0338" + ] + ] + }, + { + "input": "⋵̸", + "description": "Named entity: notindot; with a semi-colon", + "output": [ + [ + "Character", + "\u22f5\u0338" + ] + ] + }, + { + "input": "∉", + "description": "Named entity: notinva; with a semi-colon", + "output": [ + [ + "Character", + "\u2209" + ] + ] + }, + { + "input": "⋷", + "description": "Named entity: notinvb; with a semi-colon", + "output": [ + [ + "Character", + "\u22f7" + ] + ] + }, + { + "input": "⋶", + "description": "Named entity: notinvc; with a semi-colon", + "output": [ + [ + "Character", + "\u22f6" + ] + ] + }, + { + "input": "∌", + "description": "Named entity: notni; with a semi-colon", + "output": [ + [ + "Character", + "\u220c" + ] + ] + }, + { + "input": "∌", + "description": "Named entity: notniva; with a semi-colon", + "output": [ + [ + "Character", + "\u220c" + ] + ] + }, + { + "input": "⋾", + "description": "Named entity: notnivb; with a semi-colon", + "output": [ + [ + "Character", + "\u22fe" + ] + ] + }, + { + "input": "⋽", + "description": "Named entity: notnivc; with a semi-colon", + "output": [ + [ + "Character", + "\u22fd" + ] + ] + }, + { + "input": "&npar", + "description": "Bad named entity: npar without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&npar" + ] + ] + }, + { + "input": "∦", + "description": "Named entity: npar; with a semi-colon", + "output": [ + [ + "Character", + "\u2226" + ] + ] + }, + { + "input": "&nparallel", + "description": "Bad named entity: nparallel without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&nparallel" + ] + ] + }, + { + "input": "∦", + "description": "Named entity: nparallel; with a semi-colon", + "output": [ + [ + "Character", + "\u2226" + ] + ] + }, + { + "input": "&nparsl", + "description": "Bad named entity: nparsl without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&nparsl" + ] + ] + }, + { + "input": "⫽⃥", + "description": "Named entity: nparsl; with a semi-colon", + "output": [ + [ + "Character", + "\u2afd\u20e5" + ] + ] + }, + { + "input": "&npart", + "description": "Bad named entity: npart without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&npart" + ] + ] + }, + { + "input": "∂̸", + "description": "Named entity: npart; with a semi-colon", + "output": [ + [ + "Character", + "\u2202\u0338" + ] + ] + }, + { + "input": "&npolint", + "description": "Bad named entity: npolint without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&npolint" + ] + ] + }, + { + "input": "⨔", + "description": "Named entity: npolint; with a semi-colon", + "output": [ + [ + "Character", + "\u2a14" + ] + ] + }, + { + "input": "&npr", + "description": "Bad named entity: npr without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&npr" + ] + ] + }, + { + "input": "⊀", + "description": "Named entity: npr; with a semi-colon", + "output": [ + [ + "Character", + "\u2280" + ] + ] + }, + { + "input": "&nprcue", + "description": "Bad named entity: nprcue without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&nprcue" + ] + ] + }, + { + "input": "⋠", + "description": "Named entity: nprcue; with a semi-colon", + "output": [ + [ + "Character", + "\u22e0" + ] + ] + }, + { + "input": "&npre", + "description": "Bad named entity: npre without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&npre" + ] + ] + }, + { + "input": "⪯̸", + "description": "Named entity: npre; with a semi-colon", + "output": [ + [ + "Character", + "\u2aaf\u0338" + ] + ] + }, + { + "input": "&nprec", + "description": "Bad named entity: nprec without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&nprec" + ] + ] + }, + { + "input": "⊀", + "description": "Named entity: nprec; with a semi-colon", + "output": [ + [ + "Character", + "\u2280" + ] + ] + }, + { + "input": "&npreceq", + "description": "Bad named entity: npreceq without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&npreceq" + ] + ] + }, + { + "input": "⪯̸", + "description": "Named entity: npreceq; with a semi-colon", + "output": [ + [ + "Character", + "\u2aaf\u0338" + ] + ] + }, + { + "input": "&nrArr", + "description": "Bad named entity: nrArr without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&nrArr" + ] + ] + }, + { + "input": "⇏", + "description": "Named entity: nrArr; with a semi-colon", + "output": [ + [ + "Character", + "\u21cf" + ] + ] + }, + { + "input": "&nrarr", + "description": "Bad named entity: nrarr without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&nrarr" + ] + ] + }, + { + "input": "↛", + "description": "Named entity: nrarr; with a semi-colon", + "output": [ + [ + "Character", + "\u219b" + ] + ] + }, + { + "input": "&nrarrc", + "description": "Bad named entity: nrarrc without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&nrarrc" + ] + ] + }, + { + "input": "⤳̸", + "description": "Named entity: nrarrc; with a semi-colon", + "output": [ + [ + "Character", + "\u2933\u0338" + ] + ] + }, + { + "input": "&nrarrw", + "description": "Bad named entity: nrarrw without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&nrarrw" + ] + ] + }, + { + "input": "↝̸", + "description": "Named entity: nrarrw; with a semi-colon", + "output": [ + [ + "Character", + "\u219d\u0338" + ] + ] + }, + { + "input": "&nrightarrow", + "description": "Bad named entity: nrightarrow without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&nrightarrow" + ] + ] + }, + { + "input": "↛", + "description": "Named entity: nrightarrow; with a semi-colon", + "output": [ + [ + "Character", + "\u219b" + ] + ] + }, + { + "input": "&nrtri", + "description": "Bad named entity: nrtri without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&nrtri" + ] + ] + }, + { + "input": "⋫", + "description": "Named entity: nrtri; with a semi-colon", + "output": [ + [ + "Character", + "\u22eb" + ] + ] + }, + { + "input": "&nrtrie", + "description": "Bad named entity: nrtrie without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&nrtrie" + ] + ] + }, + { + "input": "⋭", + "description": "Named entity: nrtrie; with a semi-colon", + "output": [ + [ + "Character", + "\u22ed" + ] + ] + }, + { + "input": "&nsc", + "description": "Bad named entity: nsc without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&nsc" + ] + ] + }, + { + "input": "⊁", + "description": "Named entity: nsc; with a semi-colon", + "output": [ + [ + "Character", + "\u2281" + ] + ] + }, + { + "input": "&nsccue", + "description": "Bad named entity: nsccue without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&nsccue" + ] + ] + }, + { + "input": "⋡", + "description": "Named entity: nsccue; with a semi-colon", + "output": [ + [ + "Character", + "\u22e1" + ] + ] + }, + { + "input": "&nsce", + "description": "Bad named entity: nsce without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&nsce" + ] + ] + }, + { + "input": "⪰̸", + "description": "Named entity: nsce; with a semi-colon", + "output": [ + [ + "Character", + "\u2ab0\u0338" + ] + ] + }, + { + "input": "&nscr", + "description": "Bad named entity: nscr without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&nscr" + ] + ] + }, + { + "input": "𝓃", + "description": "Named entity: nscr; with a semi-colon", + "output": [ + [ + "Character", + "\ud835\udcc3" + ] + ] + }, + { + "input": "&nshortmid", + "description": "Bad named entity: nshortmid without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&nshortmid" + ] + ] + }, + { + "input": "∤", + "description": "Named entity: nshortmid; with a semi-colon", + "output": [ + [ + "Character", + "\u2224" + ] + ] + }, + { + "input": "&nshortparallel", + "description": "Bad named entity: nshortparallel without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&nshortparallel" + ] + ] + }, + { + "input": "∦", + "description": "Named entity: nshortparallel; with a semi-colon", + "output": [ + [ + "Character", + "\u2226" + ] + ] + }, + { + "input": "&nsim", + "description": "Bad named entity: nsim without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&nsim" + ] + ] + }, + { + "input": "≁", + "description": "Named entity: nsim; with a semi-colon", + "output": [ + [ + "Character", + "\u2241" + ] + ] + }, + { + "input": "&nsime", + "description": "Bad named entity: nsime without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&nsime" + ] + ] + }, + { + "input": "≄", + "description": "Named entity: nsime; with a semi-colon", + "output": [ + [ + "Character", + "\u2244" + ] + ] + }, + { + "input": "&nsimeq", + "description": "Bad named entity: nsimeq without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&nsimeq" + ] + ] + }, + { + "input": "≄", + "description": "Named entity: nsimeq; with a semi-colon", + "output": [ + [ + "Character", + "\u2244" + ] + ] + }, + { + "input": "&nsmid", + "description": "Bad named entity: nsmid without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&nsmid" + ] + ] + }, + { + "input": "∤", + "description": "Named entity: nsmid; with a semi-colon", + "output": [ + [ + "Character", + "\u2224" + ] + ] + }, + { + "input": "&nspar", + "description": "Bad named entity: nspar without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&nspar" + ] + ] + }, + { + "input": "∦", + "description": "Named entity: nspar; with a semi-colon", + "output": [ + [ + "Character", + "\u2226" + ] + ] + }, + { + "input": "&nsqsube", + "description": "Bad named entity: nsqsube without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&nsqsube" + ] + ] + }, + { + "input": "⋢", + "description": "Named entity: nsqsube; with a semi-colon", + "output": [ + [ + "Character", + "\u22e2" + ] + ] + }, + { + "input": "&nsqsupe", + "description": "Bad named entity: nsqsupe without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&nsqsupe" + ] + ] + }, + { + "input": "⋣", + "description": "Named entity: nsqsupe; with a semi-colon", + "output": [ + [ + "Character", + "\u22e3" + ] + ] + }, + { + "input": "&nsub", + "description": "Bad named entity: nsub without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&nsub" + ] + ] + }, + { + "input": "⊄", + "description": "Named entity: nsub; with a semi-colon", + "output": [ + [ + "Character", + "\u2284" + ] + ] + }, + { + "input": "&nsubE", + "description": "Bad named entity: nsubE without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&nsubE" + ] + ] + }, + { + "input": "⫅̸", + "description": "Named entity: nsubE; with a semi-colon", + "output": [ + [ + "Character", + "\u2ac5\u0338" + ] + ] + }, + { + "input": "&nsube", + "description": "Bad named entity: nsube without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&nsube" + ] + ] + }, + { + "input": "⊈", + "description": "Named entity: nsube; with a semi-colon", + "output": [ + [ + "Character", + "\u2288" + ] + ] + }, + { + "input": "&nsubset", + "description": "Bad named entity: nsubset without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&nsubset" + ] + ] + }, + { + "input": "⊂⃒", + "description": "Named entity: nsubset; with a semi-colon", + "output": [ + [ + "Character", + "\u2282\u20d2" + ] + ] + }, + { + "input": "&nsubseteq", + "description": "Bad named entity: nsubseteq without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&nsubseteq" + ] + ] + }, + { + "input": "⊈", + "description": "Named entity: nsubseteq; with a semi-colon", + "output": [ + [ + "Character", + "\u2288" + ] + ] + }, + { + "input": "&nsubseteqq", + "description": "Bad named entity: nsubseteqq without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&nsubseteqq" + ] + ] + }, + { + "input": "⫅̸", + "description": "Named entity: nsubseteqq; with a semi-colon", + "output": [ + [ + "Character", + "\u2ac5\u0338" + ] + ] + }, + { + "input": "&nsucc", + "description": "Bad named entity: nsucc without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&nsucc" + ] + ] + }, + { + "input": "⊁", + "description": "Named entity: nsucc; with a semi-colon", + "output": [ + [ + "Character", + "\u2281" + ] + ] + }, + { + "input": "&nsucceq", + "description": "Bad named entity: nsucceq without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&nsucceq" + ] + ] + }, + { + "input": "⪰̸", + "description": "Named entity: nsucceq; with a semi-colon", + "output": [ + [ + "Character", + "\u2ab0\u0338" + ] + ] + }, + { + "input": "&nsup", + "description": "Bad named entity: nsup without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&nsup" + ] + ] + }, + { + "input": "⊅", + "description": "Named entity: nsup; with a semi-colon", + "output": [ + [ + "Character", + "\u2285" + ] + ] + }, + { + "input": "&nsupE", + "description": "Bad named entity: nsupE without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&nsupE" + ] + ] + }, + { + "input": "⫆̸", + "description": "Named entity: nsupE; with a semi-colon", + "output": [ + [ + "Character", + "\u2ac6\u0338" + ] + ] + }, + { + "input": "&nsupe", + "description": "Bad named entity: nsupe without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&nsupe" + ] + ] + }, + { + "input": "⊉", + "description": "Named entity: nsupe; with a semi-colon", + "output": [ + [ + "Character", + "\u2289" + ] + ] + }, + { + "input": "&nsupset", + "description": "Bad named entity: nsupset without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&nsupset" + ] + ] + }, + { + "input": "⊃⃒", + "description": "Named entity: nsupset; with a semi-colon", + "output": [ + [ + "Character", + "\u2283\u20d2" + ] + ] + }, + { + "input": "&nsupseteq", + "description": "Bad named entity: nsupseteq without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&nsupseteq" + ] + ] + }, + { + "input": "⊉", + "description": "Named entity: nsupseteq; with a semi-colon", + "output": [ + [ + "Character", + "\u2289" + ] + ] + }, + { + "input": "&nsupseteqq", + "description": "Bad named entity: nsupseteqq without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&nsupseteqq" + ] + ] + }, + { + "input": "⫆̸", + "description": "Named entity: nsupseteqq; with a semi-colon", + "output": [ + [ + "Character", + "\u2ac6\u0338" + ] + ] + }, + { + "input": "&ntgl", + "description": "Bad named entity: ntgl without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&ntgl" + ] + ] + }, + { + "input": "≹", + "description": "Named entity: ntgl; with a semi-colon", + "output": [ + [ + "Character", + "\u2279" + ] + ] + }, + { + "input": "ñ", + "description": "Named entity: ntilde without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "\u00f1" + ] + ] + }, + { + "input": "ñ", + "description": "Named entity: ntilde; with a semi-colon", + "output": [ + [ + "Character", + "\u00f1" + ] + ] + }, + { + "input": "&ntlg", + "description": "Bad named entity: ntlg without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&ntlg" + ] + ] + }, + { + "input": "≸", + "description": "Named entity: ntlg; with a semi-colon", + "output": [ + [ + "Character", + "\u2278" + ] + ] + }, + { + "input": "&ntriangleleft", + "description": "Bad named entity: ntriangleleft without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&ntriangleleft" + ] + ] + }, + { + "input": "⋪", + "description": "Named entity: ntriangleleft; with a semi-colon", + "output": [ + [ + "Character", + "\u22ea" + ] + ] + }, + { + "input": "&ntrianglelefteq", + "description": "Bad named entity: ntrianglelefteq without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&ntrianglelefteq" + ] + ] + }, + { + "input": "⋬", + "description": "Named entity: ntrianglelefteq; with a semi-colon", + "output": [ + [ + "Character", + "\u22ec" + ] + ] + }, + { + "input": "&ntriangleright", + "description": "Bad named entity: ntriangleright without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&ntriangleright" + ] + ] + }, + { + "input": "⋫", + "description": "Named entity: ntriangleright; with a semi-colon", + "output": [ + [ + "Character", + "\u22eb" + ] + ] + }, + { + "input": "&ntrianglerighteq", + "description": "Bad named entity: ntrianglerighteq without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&ntrianglerighteq" + ] + ] + }, + { + "input": "⋭", + "description": "Named entity: ntrianglerighteq; with a semi-colon", + "output": [ + [ + "Character", + "\u22ed" + ] + ] + }, + { + "input": "&nu", + "description": "Bad named entity: nu without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&nu" + ] + ] + }, + { + "input": "ν", + "description": "Named entity: nu; with a semi-colon", + "output": [ + [ + "Character", + "\u03bd" + ] + ] + }, + { + "input": "&num", + "description": "Bad named entity: num without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&num" + ] + ] + }, + { + "input": "#", + "description": "Named entity: num; with a semi-colon", + "output": [ + [ + "Character", + "#" + ] + ] + }, + { + "input": "&numero", + "description": "Bad named entity: numero without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&numero" + ] + ] + }, + { + "input": "№", + "description": "Named entity: numero; with a semi-colon", + "output": [ + [ + "Character", + "\u2116" + ] + ] + }, + { + "input": "&numsp", + "description": "Bad named entity: numsp without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&numsp" + ] + ] + }, + { + "input": " ", + "description": "Named entity: numsp; with a semi-colon", + "output": [ + [ + "Character", + "\u2007" + ] + ] + }, + { + "input": "&nvDash", + "description": "Bad named entity: nvDash without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&nvDash" + ] + ] + }, + { + "input": "⊭", + "description": "Named entity: nvDash; with a semi-colon", + "output": [ + [ + "Character", + "\u22ad" + ] + ] + }, + { + "input": "&nvHarr", + "description": "Bad named entity: nvHarr without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&nvHarr" + ] + ] + }, + { + "input": "⤄", + "description": "Named entity: nvHarr; with a semi-colon", + "output": [ + [ + "Character", + "\u2904" + ] + ] + }, + { + "input": "&nvap", + "description": "Bad named entity: nvap without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&nvap" + ] + ] + }, + { + "input": "≍⃒", + "description": "Named entity: nvap; with a semi-colon", + "output": [ + [ + "Character", + "\u224d\u20d2" + ] + ] + }, + { + "input": "&nvdash", + "description": "Bad named entity: nvdash without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&nvdash" + ] + ] + }, + { + "input": "⊬", + "description": "Named entity: nvdash; with a semi-colon", + "output": [ + [ + "Character", + "\u22ac" + ] + ] + }, + { + "input": "&nvge", + "description": "Bad named entity: nvge without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&nvge" + ] + ] + }, + { + "input": "≥⃒", + "description": "Named entity: nvge; with a semi-colon", + "output": [ + [ + "Character", + "\u2265\u20d2" + ] + ] + }, + { + "input": "&nvgt", + "description": "Bad named entity: nvgt without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&nvgt" + ] + ] + }, + { + "input": ">⃒", + "description": "Named entity: nvgt; with a semi-colon", + "output": [ + [ + "Character", + ">\u20d2" + ] + ] + }, + { + "input": "&nvinfin", + "description": "Bad named entity: nvinfin without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&nvinfin" + ] + ] + }, + { + "input": "⧞", + "description": "Named entity: nvinfin; with a semi-colon", + "output": [ + [ + "Character", + "\u29de" + ] + ] + }, + { + "input": "&nvlArr", + "description": "Bad named entity: nvlArr without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&nvlArr" + ] + ] + }, + { + "input": "⤂", + "description": "Named entity: nvlArr; with a semi-colon", + "output": [ + [ + "Character", + "\u2902" + ] + ] + }, + { + "input": "&nvle", + "description": "Bad named entity: nvle without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&nvle" + ] + ] + }, + { + "input": "≤⃒", + "description": "Named entity: nvle; with a semi-colon", + "output": [ + [ + "Character", + "\u2264\u20d2" + ] + ] + }, + { + "input": "&nvlt", + "description": "Bad named entity: nvlt without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&nvlt" + ] + ] + }, + { + "input": "<⃒", + "description": "Named entity: nvlt; with a semi-colon", + "output": [ + [ + "Character", + "<\u20d2" + ] + ] + }, + { + "input": "&nvltrie", + "description": "Bad named entity: nvltrie without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&nvltrie" + ] + ] + }, + { + "input": "⊴⃒", + "description": "Named entity: nvltrie; with a semi-colon", + "output": [ + [ + "Character", + "\u22b4\u20d2" + ] + ] + }, + { + "input": "&nvrArr", + "description": "Bad named entity: nvrArr without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&nvrArr" + ] + ] + }, + { + "input": "⤃", + "description": "Named entity: nvrArr; with a semi-colon", + "output": [ + [ + "Character", + "\u2903" + ] + ] + }, + { + "input": "&nvrtrie", + "description": "Bad named entity: nvrtrie without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&nvrtrie" + ] + ] + }, + { + "input": "⊵⃒", + "description": "Named entity: nvrtrie; with a semi-colon", + "output": [ + [ + "Character", + "\u22b5\u20d2" + ] + ] + }, + { + "input": "&nvsim", + "description": "Bad named entity: nvsim without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&nvsim" + ] + ] + }, + { + "input": "∼⃒", + "description": "Named entity: nvsim; with a semi-colon", + "output": [ + [ + "Character", + "\u223c\u20d2" + ] + ] + }, + { + "input": "&nwArr", + "description": "Bad named entity: nwArr without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&nwArr" + ] + ] + }, + { + "input": "⇖", + "description": "Named entity: nwArr; with a semi-colon", + "output": [ + [ + "Character", + "\u21d6" + ] + ] + }, + { + "input": "&nwarhk", + "description": "Bad named entity: nwarhk without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&nwarhk" + ] + ] + }, + { + "input": "⤣", + "description": "Named entity: nwarhk; with a semi-colon", + "output": [ + [ + "Character", + "\u2923" + ] + ] + }, + { + "input": "&nwarr", + "description": "Bad named entity: nwarr without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&nwarr" + ] + ] + }, + { + "input": "↖", + "description": "Named entity: nwarr; with a semi-colon", + "output": [ + [ + "Character", + "\u2196" + ] + ] + }, + { + "input": "&nwarrow", + "description": "Bad named entity: nwarrow without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&nwarrow" + ] + ] + }, + { + "input": "↖", + "description": "Named entity: nwarrow; with a semi-colon", + "output": [ + [ + "Character", + "\u2196" + ] + ] + }, + { + "input": "&nwnear", + "description": "Bad named entity: nwnear without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&nwnear" + ] + ] + }, + { + "input": "⤧", + "description": "Named entity: nwnear; with a semi-colon", + "output": [ + [ + "Character", + "\u2927" + ] + ] + }, + { + "input": "&oS", + "description": "Bad named entity: oS without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&oS" + ] + ] + }, + { + "input": "Ⓢ", + "description": "Named entity: oS; with a semi-colon", + "output": [ + [ + "Character", + "\u24c8" + ] + ] + }, + { + "input": "ó", + "description": "Named entity: oacute without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "\u00f3" + ] + ] + }, + { + "input": "ó", + "description": "Named entity: oacute; with a semi-colon", + "output": [ + [ + "Character", + "\u00f3" + ] + ] + }, + { + "input": "&oast", + "description": "Bad named entity: oast without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&oast" + ] + ] + }, + { + "input": "⊛", + "description": "Named entity: oast; with a semi-colon", + "output": [ + [ + "Character", + "\u229b" + ] + ] + }, + { + "input": "&ocir", + "description": "Bad named entity: ocir without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&ocir" + ] + ] + }, + { + "input": "⊚", + "description": "Named entity: ocir; with a semi-colon", + "output": [ + [ + "Character", + "\u229a" + ] + ] + }, + { + "input": "ô", + "description": "Named entity: ocirc without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "\u00f4" + ] + ] + }, + { + "input": "ô", + "description": "Named entity: ocirc; with a semi-colon", + "output": [ + [ + "Character", + "\u00f4" + ] + ] + }, + { + "input": "&ocy", + "description": "Bad named entity: ocy without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&ocy" + ] + ] + }, + { + "input": "о", + "description": "Named entity: ocy; with a semi-colon", + "output": [ + [ + "Character", + "\u043e" + ] + ] + }, + { + "input": "&odash", + "description": "Bad named entity: odash without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&odash" + ] + ] + }, + { + "input": "⊝", + "description": "Named entity: odash; with a semi-colon", + "output": [ + [ + "Character", + "\u229d" + ] + ] + }, + { + "input": "&odblac", + "description": "Bad named entity: odblac without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&odblac" + ] + ] + }, + { + "input": "ő", + "description": "Named entity: odblac; with a semi-colon", + "output": [ + [ + "Character", + "\u0151" + ] + ] + }, + { + "input": "&odiv", + "description": "Bad named entity: odiv without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&odiv" + ] + ] + }, + { + "input": "⨸", + "description": "Named entity: odiv; with a semi-colon", + "output": [ + [ + "Character", + "\u2a38" + ] + ] + }, + { + "input": "&odot", + "description": "Bad named entity: odot without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&odot" + ] + ] + }, + { + "input": "⊙", + "description": "Named entity: odot; with a semi-colon", + "output": [ + [ + "Character", + "\u2299" + ] + ] + }, + { + "input": "&odsold", + "description": "Bad named entity: odsold without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&odsold" + ] + ] + }, + { + "input": "⦼", + "description": "Named entity: odsold; with a semi-colon", + "output": [ + [ + "Character", + "\u29bc" + ] + ] + }, + { + "input": "&oelig", + "description": "Bad named entity: oelig without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&oelig" + ] + ] + }, + { + "input": "œ", + "description": "Named entity: oelig; with a semi-colon", + "output": [ + [ + "Character", + "\u0153" + ] + ] + }, + { + "input": "&ofcir", + "description": "Bad named entity: ofcir without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&ofcir" + ] + ] + }, + { + "input": "⦿", + "description": "Named entity: ofcir; with a semi-colon", + "output": [ + [ + "Character", + "\u29bf" + ] + ] + }, + { + "input": "&ofr", + "description": "Bad named entity: ofr without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&ofr" + ] + ] + }, + { + "input": "𝔬", + "description": "Named entity: ofr; with a semi-colon", + "output": [ + [ + "Character", + "\ud835\udd2c" + ] + ] + }, + { + "input": "&ogon", + "description": "Bad named entity: ogon without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&ogon" + ] + ] + }, + { + "input": "˛", + "description": "Named entity: ogon; with a semi-colon", + "output": [ + [ + "Character", + "\u02db" + ] + ] + }, + { + "input": "ò", + "description": "Named entity: ograve without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "\u00f2" + ] + ] + }, + { + "input": "ò", + "description": "Named entity: ograve; with a semi-colon", + "output": [ + [ + "Character", + "\u00f2" + ] + ] + }, + { + "input": "&ogt", + "description": "Bad named entity: ogt without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&ogt" + ] + ] + }, + { + "input": "⧁", + "description": "Named entity: ogt; with a semi-colon", + "output": [ + [ + "Character", + "\u29c1" + ] + ] + }, + { + "input": "&ohbar", + "description": "Bad named entity: ohbar without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&ohbar" + ] + ] + }, + { + "input": "⦵", + "description": "Named entity: ohbar; with a semi-colon", + "output": [ + [ + "Character", + "\u29b5" + ] + ] + }, + { + "input": "&ohm", + "description": "Bad named entity: ohm without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&ohm" + ] + ] + }, + { + "input": "Ω", + "description": "Named entity: ohm; with a semi-colon", + "output": [ + [ + "Character", + "\u03a9" + ] + ] + }, + { + "input": "&oint", + "description": "Bad named entity: oint without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&oint" + ] + ] + }, + { + "input": "∮", + "description": "Named entity: oint; with a semi-colon", + "output": [ + [ + "Character", + "\u222e" + ] + ] + }, + { + "input": "&olarr", + "description": "Bad named entity: olarr without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&olarr" + ] + ] + }, + { + "input": "↺", + "description": "Named entity: olarr; with a semi-colon", + "output": [ + [ + "Character", + "\u21ba" + ] + ] + }, + { + "input": "&olcir", + "description": "Bad named entity: olcir without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&olcir" + ] + ] + }, + { + "input": "⦾", + "description": "Named entity: olcir; with a semi-colon", + "output": [ + [ + "Character", + "\u29be" + ] + ] + }, + { + "input": "&olcross", + "description": "Bad named entity: olcross without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&olcross" + ] + ] + }, + { + "input": "⦻", + "description": "Named entity: olcross; with a semi-colon", + "output": [ + [ + "Character", + "\u29bb" + ] + ] + }, + { + "input": "&oline", + "description": "Bad named entity: oline without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&oline" + ] + ] + }, + { + "input": "‾", + "description": "Named entity: oline; with a semi-colon", + "output": [ + [ + "Character", + "\u203e" + ] + ] + }, + { + "input": "&olt", + "description": "Bad named entity: olt without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&olt" + ] + ] + }, + { + "input": "⧀", + "description": "Named entity: olt; with a semi-colon", + "output": [ + [ + "Character", + "\u29c0" + ] + ] + }, + { + "input": "&omacr", + "description": "Bad named entity: omacr without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&omacr" + ] + ] + }, + { + "input": "ō", + "description": "Named entity: omacr; with a semi-colon", + "output": [ + [ + "Character", + "\u014d" + ] + ] + }, + { + "input": "&omega", + "description": "Bad named entity: omega without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&omega" + ] + ] + }, + { + "input": "ω", + "description": "Named entity: omega; with a semi-colon", + "output": [ + [ + "Character", + "\u03c9" + ] + ] + }, + { + "input": "&omicron", + "description": "Bad named entity: omicron without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&omicron" + ] + ] + }, + { + "input": "ο", + "description": "Named entity: omicron; with a semi-colon", + "output": [ + [ + "Character", + "\u03bf" + ] + ] + }, + { + "input": "&omid", + "description": "Bad named entity: omid without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&omid" + ] + ] + }, + { + "input": "⦶", + "description": "Named entity: omid; with a semi-colon", + "output": [ + [ + "Character", + "\u29b6" + ] + ] + }, + { + "input": "&ominus", + "description": "Bad named entity: ominus without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&ominus" + ] + ] + }, + { + "input": "⊖", + "description": "Named entity: ominus; with a semi-colon", + "output": [ + [ + "Character", + "\u2296" + ] + ] + }, + { + "input": "&oopf", + "description": "Bad named entity: oopf without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&oopf" + ] + ] + }, + { + "input": "𝕠", + "description": "Named entity: oopf; with a semi-colon", + "output": [ + [ + "Character", + "\ud835\udd60" + ] + ] + }, + { + "input": "&opar", + "description": "Bad named entity: opar without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&opar" + ] + ] + }, + { + "input": "⦷", + "description": "Named entity: opar; with a semi-colon", + "output": [ + [ + "Character", + "\u29b7" + ] + ] + }, + { + "input": "&operp", + "description": "Bad named entity: operp without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&operp" + ] + ] + }, + { + "input": "⦹", + "description": "Named entity: operp; with a semi-colon", + "output": [ + [ + "Character", + "\u29b9" + ] + ] + }, + { + "input": "&oplus", + "description": "Bad named entity: oplus without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&oplus" + ] + ] + }, + { + "input": "⊕", + "description": "Named entity: oplus; with a semi-colon", + "output": [ + [ + "Character", + "\u2295" + ] + ] + }, + { + "input": "&or", + "description": "Bad named entity: or without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&or" + ] + ] + }, + { + "input": "∨", + "description": "Named entity: or; with a semi-colon", + "output": [ + [ + "Character", + "\u2228" + ] + ] + }, + { + "input": "&orarr", + "description": "Bad named entity: orarr without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&orarr" + ] + ] + }, + { + "input": "↻", + "description": "Named entity: orarr; with a semi-colon", + "output": [ + [ + "Character", + "\u21bb" + ] + ] + }, + { + "input": "&ord", + "description": "Bad named entity: ord without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&ord" + ] + ] + }, + { + "input": "⩝", + "description": "Named entity: ord; with a semi-colon", + "output": [ + [ + "Character", + "\u2a5d" + ] + ] + }, + { + "input": "&order", + "description": "Bad named entity: order without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&order" + ] + ] + }, + { + "input": "ℴ", + "description": "Named entity: order; with a semi-colon", + "output": [ + [ + "Character", + "\u2134" + ] + ] + }, + { + "input": "&orderof", + "description": "Bad named entity: orderof without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&orderof" + ] + ] + }, + { + "input": "ℴ", + "description": "Named entity: orderof; with a semi-colon", + "output": [ + [ + "Character", + "\u2134" + ] + ] + }, + { + "input": "ª", + "description": "Named entity: ordf without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "\u00aa" + ] + ] + }, + { + "input": "ª", + "description": "Named entity: ordf; with a semi-colon", + "output": [ + [ + "Character", + "\u00aa" + ] + ] + }, + { + "input": "º", + "description": "Named entity: ordm without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "\u00ba" + ] + ] + }, + { + "input": "º", + "description": "Named entity: ordm; with a semi-colon", + "output": [ + [ + "Character", + "\u00ba" + ] + ] + }, + { + "input": "&origof", + "description": "Bad named entity: origof without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&origof" + ] + ] + }, + { + "input": "⊶", + "description": "Named entity: origof; with a semi-colon", + "output": [ + [ + "Character", + "\u22b6" + ] + ] + }, + { + "input": "&oror", + "description": "Bad named entity: oror without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&oror" + ] + ] + }, + { + "input": "⩖", + "description": "Named entity: oror; with a semi-colon", + "output": [ + [ + "Character", + "\u2a56" + ] + ] + }, + { + "input": "&orslope", + "description": "Bad named entity: orslope without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&orslope" + ] + ] + }, + { + "input": "⩗", + "description": "Named entity: orslope; with a semi-colon", + "output": [ + [ + "Character", + "\u2a57" + ] + ] + }, + { + "input": "&orv", + "description": "Bad named entity: orv without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&orv" + ] + ] + }, + { + "input": "⩛", + "description": "Named entity: orv; with a semi-colon", + "output": [ + [ + "Character", + "\u2a5b" + ] + ] + }, + { + "input": "&oscr", + "description": "Bad named entity: oscr without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&oscr" + ] + ] + }, + { + "input": "ℴ", + "description": "Named entity: oscr; with a semi-colon", + "output": [ + [ + "Character", + "\u2134" + ] + ] + }, + { + "input": "ø", + "description": "Named entity: oslash without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "\u00f8" + ] + ] + }, + { + "input": "ø", + "description": "Named entity: oslash; with a semi-colon", + "output": [ + [ + "Character", + "\u00f8" + ] + ] + }, + { + "input": "&osol", + "description": "Bad named entity: osol without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&osol" + ] + ] + }, + { + "input": "⊘", + "description": "Named entity: osol; with a semi-colon", + "output": [ + [ + "Character", + "\u2298" + ] + ] + }, + { + "input": "õ", + "description": "Named entity: otilde without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "\u00f5" + ] + ] + }, + { + "input": "õ", + "description": "Named entity: otilde; with a semi-colon", + "output": [ + [ + "Character", + "\u00f5" + ] + ] + }, + { + "input": "&otimes", + "description": "Bad named entity: otimes without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&otimes" + ] + ] + }, + { + "input": "⊗", + "description": "Named entity: otimes; with a semi-colon", + "output": [ + [ + "Character", + "\u2297" + ] + ] + }, + { + "input": "&otimesas", + "description": "Bad named entity: otimesas without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&otimesas" + ] + ] + }, + { + "input": "⨶", + "description": "Named entity: otimesas; with a semi-colon", + "output": [ + [ + "Character", + "\u2a36" + ] + ] + }, + { + "input": "ö", + "description": "Named entity: ouml without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "\u00f6" + ] + ] + }, + { + "input": "ö", + "description": "Named entity: ouml; with a semi-colon", + "output": [ + [ + "Character", + "\u00f6" + ] + ] + }, + { + "input": "&ovbar", + "description": "Bad named entity: ovbar without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&ovbar" + ] + ] + }, + { + "input": "⌽", + "description": "Named entity: ovbar; with a semi-colon", + "output": [ + [ + "Character", + "\u233d" + ] + ] + }, + { + "input": "&par", + "description": "Bad named entity: par without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&par" + ] + ] + }, + { + "input": "∥", + "description": "Named entity: par; with a semi-colon", + "output": [ + [ + "Character", + "\u2225" + ] + ] + }, + { + "input": "¶", + "description": "Named entity: para without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "\u00b6" + ] + ] + }, + { + "input": "¶", + "description": "Named entity: para; with a semi-colon", + "output": [ + [ + "Character", + "\u00b6" + ] + ] + }, + { + "input": "∥", + "description": "Named entity: parallel; with a semi-colon", + "output": [ + [ + "Character", + "\u2225" + ] + ] + }, + { + "input": "&parsim", + "description": "Bad named entity: parsim without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&parsim" + ] + ] + }, + { + "input": "⫳", + "description": "Named entity: parsim; with a semi-colon", + "output": [ + [ + "Character", + "\u2af3" + ] + ] + }, + { + "input": "&parsl", + "description": "Bad named entity: parsl without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&parsl" + ] + ] + }, + { + "input": "⫽", + "description": "Named entity: parsl; with a semi-colon", + "output": [ + [ + "Character", + "\u2afd" + ] + ] + }, + { + "input": "&part", + "description": "Bad named entity: part without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&part" + ] + ] + }, + { + "input": "∂", + "description": "Named entity: part; with a semi-colon", + "output": [ + [ + "Character", + "\u2202" + ] + ] + }, + { + "input": "&pcy", + "description": "Bad named entity: pcy without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&pcy" + ] + ] + }, + { + "input": "п", + "description": "Named entity: pcy; with a semi-colon", + "output": [ + [ + "Character", + "\u043f" + ] + ] + }, + { + "input": "&percnt", + "description": "Bad named entity: percnt without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&percnt" + ] + ] + }, + { + "input": "%", + "description": "Named entity: percnt; with a semi-colon", + "output": [ + [ + "Character", + "%" + ] + ] + }, + { + "input": "&period", + "description": "Bad named entity: period without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&period" + ] + ] + }, + { + "input": ".", + "description": "Named entity: period; with a semi-colon", + "output": [ + [ + "Character", + "." + ] + ] + }, + { + "input": "&permil", + "description": "Bad named entity: permil without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&permil" + ] + ] + }, + { + "input": "‰", + "description": "Named entity: permil; with a semi-colon", + "output": [ + [ + "Character", + "\u2030" + ] + ] + }, + { + "input": "&perp", + "description": "Bad named entity: perp without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&perp" + ] + ] + }, + { + "input": "⊥", + "description": "Named entity: perp; with a semi-colon", + "output": [ + [ + "Character", + "\u22a5" + ] + ] + }, + { + "input": "&pertenk", + "description": "Bad named entity: pertenk without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&pertenk" + ] + ] + }, + { + "input": "‱", + "description": "Named entity: pertenk; with a semi-colon", + "output": [ + [ + "Character", + "\u2031" + ] + ] + }, + { + "input": "&pfr", + "description": "Bad named entity: pfr without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&pfr" + ] + ] + }, + { + "input": "𝔭", + "description": "Named entity: pfr; with a semi-colon", + "output": [ + [ + "Character", + "\ud835\udd2d" + ] + ] + }, + { + "input": "&phi", + "description": "Bad named entity: phi without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&phi" + ] + ] + }, + { + "input": "φ", + "description": "Named entity: phi; with a semi-colon", + "output": [ + [ + "Character", + "\u03c6" + ] + ] + }, + { + "input": "&phiv", + "description": "Bad named entity: phiv without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&phiv" + ] + ] + }, + { + "input": "ϕ", + "description": "Named entity: phiv; with a semi-colon", + "output": [ + [ + "Character", + "\u03d5" + ] + ] + }, + { + "input": "&phmmat", + "description": "Bad named entity: phmmat without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&phmmat" + ] + ] + }, + { + "input": "ℳ", + "description": "Named entity: phmmat; with a semi-colon", + "output": [ + [ + "Character", + "\u2133" + ] + ] + }, + { + "input": "&phone", + "description": "Bad named entity: phone without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&phone" + ] + ] + }, + { + "input": "☎", + "description": "Named entity: phone; with a semi-colon", + "output": [ + [ + "Character", + "\u260e" + ] + ] + }, + { + "input": "&pi", + "description": "Bad named entity: pi without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&pi" + ] + ] + }, + { + "input": "π", + "description": "Named entity: pi; with a semi-colon", + "output": [ + [ + "Character", + "\u03c0" + ] + ] + }, + { + "input": "&pitchfork", + "description": "Bad named entity: pitchfork without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&pitchfork" + ] + ] + }, + { + "input": "⋔", + "description": "Named entity: pitchfork; with a semi-colon", + "output": [ + [ + "Character", + "\u22d4" + ] + ] + }, + { + "input": "&piv", + "description": "Bad named entity: piv without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&piv" + ] + ] + }, + { + "input": "ϖ", + "description": "Named entity: piv; with a semi-colon", + "output": [ + [ + "Character", + "\u03d6" + ] + ] + }, + { + "input": "&planck", + "description": "Bad named entity: planck without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&planck" + ] + ] + }, + { + "input": "ℏ", + "description": "Named entity: planck; with a semi-colon", + "output": [ + [ + "Character", + "\u210f" + ] + ] + }, + { + "input": "&planckh", + "description": "Bad named entity: planckh without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&planckh" + ] + ] + }, + { + "input": "ℎ", + "description": "Named entity: planckh; with a semi-colon", + "output": [ + [ + "Character", + "\u210e" + ] + ] + }, + { + "input": "&plankv", + "description": "Bad named entity: plankv without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&plankv" + ] + ] + }, + { + "input": "ℏ", + "description": "Named entity: plankv; with a semi-colon", + "output": [ + [ + "Character", + "\u210f" + ] + ] + }, + { + "input": "&plus", + "description": "Bad named entity: plus without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&plus" + ] + ] + }, + { + "input": "+", + "description": "Named entity: plus; with a semi-colon", + "output": [ + [ + "Character", + "+" + ] + ] + }, + { + "input": "&plusacir", + "description": "Bad named entity: plusacir without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&plusacir" + ] + ] + }, + { + "input": "⨣", + "description": "Named entity: plusacir; with a semi-colon", + "output": [ + [ + "Character", + "\u2a23" + ] + ] + }, + { + "input": "&plusb", + "description": "Bad named entity: plusb without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&plusb" + ] + ] + }, + { + "input": "⊞", + "description": "Named entity: plusb; with a semi-colon", + "output": [ + [ + "Character", + "\u229e" + ] + ] + }, + { + "input": "&pluscir", + "description": "Bad named entity: pluscir without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&pluscir" + ] + ] + }, + { + "input": "⨢", + "description": "Named entity: pluscir; with a semi-colon", + "output": [ + [ + "Character", + "\u2a22" + ] + ] + }, + { + "input": "&plusdo", + "description": "Bad named entity: plusdo without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&plusdo" + ] + ] + }, + { + "input": "∔", + "description": "Named entity: plusdo; with a semi-colon", + "output": [ + [ + "Character", + "\u2214" + ] + ] + }, + { + "input": "&plusdu", + "description": "Bad named entity: plusdu without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&plusdu" + ] + ] + }, + { + "input": "⨥", + "description": "Named entity: plusdu; with a semi-colon", + "output": [ + [ + "Character", + "\u2a25" + ] + ] + }, + { + "input": "&pluse", + "description": "Bad named entity: pluse without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&pluse" + ] + ] + }, + { + "input": "⩲", + "description": "Named entity: pluse; with a semi-colon", + "output": [ + [ + "Character", + "\u2a72" + ] + ] + }, + { + "input": "±", + "description": "Named entity: plusmn without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "\u00b1" + ] + ] + }, + { + "input": "±", + "description": "Named entity: plusmn; with a semi-colon", + "output": [ + [ + "Character", + "\u00b1" + ] + ] + }, + { + "input": "&plussim", + "description": "Bad named entity: plussim without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&plussim" + ] + ] + }, + { + "input": "⨦", + "description": "Named entity: plussim; with a semi-colon", + "output": [ + [ + "Character", + "\u2a26" + ] + ] + }, + { + "input": "&plustwo", + "description": "Bad named entity: plustwo without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&plustwo" + ] + ] + }, + { + "input": "⨧", + "description": "Named entity: plustwo; with a semi-colon", + "output": [ + [ + "Character", + "\u2a27" + ] + ] + }, + { + "input": "&pm", + "description": "Bad named entity: pm without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&pm" + ] + ] + }, + { + "input": "±", + "description": "Named entity: pm; with a semi-colon", + "output": [ + [ + "Character", + "\u00b1" + ] + ] + }, + { + "input": "&pointint", + "description": "Bad named entity: pointint without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&pointint" + ] + ] + }, + { + "input": "⨕", + "description": "Named entity: pointint; with a semi-colon", + "output": [ + [ + "Character", + "\u2a15" + ] + ] + }, + { + "input": "&popf", + "description": "Bad named entity: popf without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&popf" + ] + ] + }, + { + "input": "𝕡", + "description": "Named entity: popf; with a semi-colon", + "output": [ + [ + "Character", + "\ud835\udd61" + ] + ] + }, + { + "input": "£", + "description": "Named entity: pound without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "\u00a3" + ] + ] + }, + { + "input": "£", + "description": "Named entity: pound; with a semi-colon", + "output": [ + [ + "Character", + "\u00a3" + ] + ] + }, + { + "input": "&pr", + "description": "Bad named entity: pr without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&pr" + ] + ] + }, + { + "input": "≺", + "description": "Named entity: pr; with a semi-colon", + "output": [ + [ + "Character", + "\u227a" + ] + ] + }, + { + "input": "&prE", + "description": "Bad named entity: prE without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&prE" + ] + ] + }, + { + "input": "⪳", + "description": "Named entity: prE; with a semi-colon", + "output": [ + [ + "Character", + "\u2ab3" + ] + ] + }, + { + "input": "&prap", + "description": "Bad named entity: prap without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&prap" + ] + ] + }, + { + "input": "⪷", + "description": "Named entity: prap; with a semi-colon", + "output": [ + [ + "Character", + "\u2ab7" + ] + ] + }, + { + "input": "&prcue", + "description": "Bad named entity: prcue without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&prcue" + ] + ] + }, + { + "input": "≼", + "description": "Named entity: prcue; with a semi-colon", + "output": [ + [ + "Character", + "\u227c" + ] + ] + }, + { + "input": "&pre", + "description": "Bad named entity: pre without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&pre" + ] + ] + }, + { + "input": "⪯", + "description": "Named entity: pre; with a semi-colon", + "output": [ + [ + "Character", + "\u2aaf" + ] + ] + }, + { + "input": "&prec", + "description": "Bad named entity: prec without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&prec" + ] + ] + }, + { + "input": "≺", + "description": "Named entity: prec; with a semi-colon", + "output": [ + [ + "Character", + "\u227a" + ] + ] + }, + { + "input": "&precapprox", + "description": "Bad named entity: precapprox without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&precapprox" + ] + ] + }, + { + "input": "⪷", + "description": "Named entity: precapprox; with a semi-colon", + "output": [ + [ + "Character", + "\u2ab7" + ] + ] + }, + { + "input": "&preccurlyeq", + "description": "Bad named entity: preccurlyeq without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&preccurlyeq" + ] + ] + }, + { + "input": "≼", + "description": "Named entity: preccurlyeq; with a semi-colon", + "output": [ + [ + "Character", + "\u227c" + ] + ] + }, + { + "input": "&preceq", + "description": "Bad named entity: preceq without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&preceq" + ] + ] + }, + { + "input": "⪯", + "description": "Named entity: preceq; with a semi-colon", + "output": [ + [ + "Character", + "\u2aaf" + ] + ] + }, + { + "input": "&precnapprox", + "description": "Bad named entity: precnapprox without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&precnapprox" + ] + ] + }, + { + "input": "⪹", + "description": "Named entity: precnapprox; with a semi-colon", + "output": [ + [ + "Character", + "\u2ab9" + ] + ] + }, + { + "input": "&precneqq", + "description": "Bad named entity: precneqq without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&precneqq" + ] + ] + }, + { + "input": "⪵", + "description": "Named entity: precneqq; with a semi-colon", + "output": [ + [ + "Character", + "\u2ab5" + ] + ] + }, + { + "input": "&precnsim", + "description": "Bad named entity: precnsim without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&precnsim" + ] + ] + }, + { + "input": "⋨", + "description": "Named entity: precnsim; with a semi-colon", + "output": [ + [ + "Character", + "\u22e8" + ] + ] + }, + { + "input": "&precsim", + "description": "Bad named entity: precsim without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&precsim" + ] + ] + }, + { + "input": "≾", + "description": "Named entity: precsim; with a semi-colon", + "output": [ + [ + "Character", + "\u227e" + ] + ] + }, + { + "input": "&prime", + "description": "Bad named entity: prime without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&prime" + ] + ] + }, + { + "input": "′", + "description": "Named entity: prime; with a semi-colon", + "output": [ + [ + "Character", + "\u2032" + ] + ] + }, + { + "input": "&primes", + "description": "Bad named entity: primes without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&primes" + ] + ] + }, + { + "input": "ℙ", + "description": "Named entity: primes; with a semi-colon", + "output": [ + [ + "Character", + "\u2119" + ] + ] + }, + { + "input": "&prnE", + "description": "Bad named entity: prnE without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&prnE" + ] + ] + }, + { + "input": "⪵", + "description": "Named entity: prnE; with a semi-colon", + "output": [ + [ + "Character", + "\u2ab5" + ] + ] + }, + { + "input": "&prnap", + "description": "Bad named entity: prnap without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&prnap" + ] + ] + }, + { + "input": "⪹", + "description": "Named entity: prnap; with a semi-colon", + "output": [ + [ + "Character", + "\u2ab9" + ] + ] + }, + { + "input": "&prnsim", + "description": "Bad named entity: prnsim without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&prnsim" + ] + ] + }, + { + "input": "⋨", + "description": "Named entity: prnsim; with a semi-colon", + "output": [ + [ + "Character", + "\u22e8" + ] + ] + }, + { + "input": "&prod", + "description": "Bad named entity: prod without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&prod" + ] + ] + }, + { + "input": "∏", + "description": "Named entity: prod; with a semi-colon", + "output": [ + [ + "Character", + "\u220f" + ] + ] + }, + { + "input": "&profalar", + "description": "Bad named entity: profalar without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&profalar" + ] + ] + }, + { + "input": "⌮", + "description": "Named entity: profalar; with a semi-colon", + "output": [ + [ + "Character", + "\u232e" + ] + ] + }, + { + "input": "&profline", + "description": "Bad named entity: profline without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&profline" + ] + ] + }, + { + "input": "⌒", + "description": "Named entity: profline; with a semi-colon", + "output": [ + [ + "Character", + "\u2312" + ] + ] + }, + { + "input": "&profsurf", + "description": "Bad named entity: profsurf without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&profsurf" + ] + ] + }, + { + "input": "⌓", + "description": "Named entity: profsurf; with a semi-colon", + "output": [ + [ + "Character", + "\u2313" + ] + ] + }, + { + "input": "&prop", + "description": "Bad named entity: prop without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&prop" + ] + ] + }, + { + "input": "∝", + "description": "Named entity: prop; with a semi-colon", + "output": [ + [ + "Character", + "\u221d" + ] + ] + }, + { + "input": "&propto", + "description": "Bad named entity: propto without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&propto" + ] + ] + }, + { + "input": "∝", + "description": "Named entity: propto; with a semi-colon", + "output": [ + [ + "Character", + "\u221d" + ] + ] + }, + { + "input": "&prsim", + "description": "Bad named entity: prsim without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&prsim" + ] + ] + }, + { + "input": "≾", + "description": "Named entity: prsim; with a semi-colon", + "output": [ + [ + "Character", + "\u227e" + ] + ] + }, + { + "input": "&prurel", + "description": "Bad named entity: prurel without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&prurel" + ] + ] + }, + { + "input": "⊰", + "description": "Named entity: prurel; with a semi-colon", + "output": [ + [ + "Character", + "\u22b0" + ] + ] + }, + { + "input": "&pscr", + "description": "Bad named entity: pscr without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&pscr" + ] + ] + }, + { + "input": "𝓅", + "description": "Named entity: pscr; with a semi-colon", + "output": [ + [ + "Character", + "\ud835\udcc5" + ] + ] + }, + { + "input": "&psi", + "description": "Bad named entity: psi without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&psi" + ] + ] + }, + { + "input": "ψ", + "description": "Named entity: psi; with a semi-colon", + "output": [ + [ + "Character", + "\u03c8" + ] + ] + }, + { + "input": "&puncsp", + "description": "Bad named entity: puncsp without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&puncsp" + ] + ] + }, + { + "input": " ", + "description": "Named entity: puncsp; with a semi-colon", + "output": [ + [ + "Character", + "\u2008" + ] + ] + }, + { + "input": "&qfr", + "description": "Bad named entity: qfr without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&qfr" + ] + ] + }, + { + "input": "𝔮", + "description": "Named entity: qfr; with a semi-colon", + "output": [ + [ + "Character", + "\ud835\udd2e" + ] + ] + }, + { + "input": "&qint", + "description": "Bad named entity: qint without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&qint" + ] + ] + }, + { + "input": "⨌", + "description": "Named entity: qint; with a semi-colon", + "output": [ + [ + "Character", + "\u2a0c" + ] + ] + }, + { + "input": "&qopf", + "description": "Bad named entity: qopf without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&qopf" + ] + ] + }, + { + "input": "𝕢", + "description": "Named entity: qopf; with a semi-colon", + "output": [ + [ + "Character", + "\ud835\udd62" + ] + ] + }, + { + "input": "&qprime", + "description": "Bad named entity: qprime without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&qprime" + ] + ] + }, + { + "input": "⁗", + "description": "Named entity: qprime; with a semi-colon", + "output": [ + [ + "Character", + "\u2057" + ] + ] + }, + { + "input": "&qscr", + "description": "Bad named entity: qscr without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&qscr" + ] + ] + }, + { + "input": "𝓆", + "description": "Named entity: qscr; with a semi-colon", + "output": [ + [ + "Character", + "\ud835\udcc6" + ] + ] + }, + { + "input": "&quaternions", + "description": "Bad named entity: quaternions without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&quaternions" + ] + ] + }, + { + "input": "ℍ", + "description": "Named entity: quaternions; with a semi-colon", + "output": [ + [ + "Character", + "\u210d" + ] + ] + }, + { + "input": "&quatint", + "description": "Bad named entity: quatint without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&quatint" + ] + ] + }, + { + "input": "⨖", + "description": "Named entity: quatint; with a semi-colon", + "output": [ + [ + "Character", + "\u2a16" + ] + ] + }, + { + "input": "&quest", + "description": "Bad named entity: quest without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&quest" + ] + ] + }, + { + "input": "?", + "description": "Named entity: quest; with a semi-colon", + "output": [ + [ + "Character", + "?" + ] + ] + }, + { + "input": "&questeq", + "description": "Bad named entity: questeq without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&questeq" + ] + ] + }, + { + "input": "≟", + "description": "Named entity: questeq; with a semi-colon", + "output": [ + [ + "Character", + "\u225f" + ] + ] + }, + { + "input": """, + "description": "Named entity: quot without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "\"" + ] + ] + }, + { + "input": """, + "description": "Named entity: quot; with a semi-colon", + "output": [ + [ + "Character", + "\"" + ] + ] + }, + { + "input": "&rAarr", + "description": "Bad named entity: rAarr without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&rAarr" + ] + ] + }, + { + "input": "⇛", + "description": "Named entity: rAarr; with a semi-colon", + "output": [ + [ + "Character", + "\u21db" + ] + ] + }, + { + "input": "&rArr", + "description": "Bad named entity: rArr without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&rArr" + ] + ] + }, + { + "input": "⇒", + "description": "Named entity: rArr; with a semi-colon", + "output": [ + [ + "Character", + "\u21d2" + ] + ] + }, + { + "input": "&rAtail", + "description": "Bad named entity: rAtail without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&rAtail" + ] + ] + }, + { + "input": "⤜", + "description": "Named entity: rAtail; with a semi-colon", + "output": [ + [ + "Character", + "\u291c" + ] + ] + }, + { + "input": "&rBarr", + "description": "Bad named entity: rBarr without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&rBarr" + ] + ] + }, + { + "input": "⤏", + "description": "Named entity: rBarr; with a semi-colon", + "output": [ + [ + "Character", + "\u290f" + ] + ] + }, + { + "input": "&rHar", + "description": "Bad named entity: rHar without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&rHar" + ] + ] + }, + { + "input": "⥤", + "description": "Named entity: rHar; with a semi-colon", + "output": [ + [ + "Character", + "\u2964" + ] + ] + }, + { + "input": "&race", + "description": "Bad named entity: race without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&race" + ] + ] + }, + { + "input": "∽̱", + "description": "Named entity: race; with a semi-colon", + "output": [ + [ + "Character", + "\u223d\u0331" + ] + ] + }, + { + "input": "&racute", + "description": "Bad named entity: racute without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&racute" + ] + ] + }, + { + "input": "ŕ", + "description": "Named entity: racute; with a semi-colon", + "output": [ + [ + "Character", + "\u0155" + ] + ] + }, + { + "input": "&radic", + "description": "Bad named entity: radic without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&radic" + ] + ] + }, + { + "input": "√", + "description": "Named entity: radic; with a semi-colon", + "output": [ + [ + "Character", + "\u221a" + ] + ] + }, + { + "input": "&raemptyv", + "description": "Bad named entity: raemptyv without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&raemptyv" + ] + ] + }, + { + "input": "⦳", + "description": "Named entity: raemptyv; with a semi-colon", + "output": [ + [ + "Character", + "\u29b3" + ] + ] + }, + { + "input": "&rang", + "description": "Bad named entity: rang without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&rang" + ] + ] + }, + { + "input": "⟩", + "description": "Named entity: rang; with a semi-colon", + "output": [ + [ + "Character", + "\u27e9" + ] + ] + }, + { + "input": "&rangd", + "description": "Bad named entity: rangd without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&rangd" + ] + ] + }, + { + "input": "⦒", + "description": "Named entity: rangd; with a semi-colon", + "output": [ + [ + "Character", + "\u2992" + ] + ] + }, + { + "input": "&range", + "description": "Bad named entity: range without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&range" + ] + ] + }, + { + "input": "⦥", + "description": "Named entity: range; with a semi-colon", + "output": [ + [ + "Character", + "\u29a5" + ] + ] + }, + { + "input": "&rangle", + "description": "Bad named entity: rangle without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&rangle" + ] + ] + }, + { + "input": "⟩", + "description": "Named entity: rangle; with a semi-colon", + "output": [ + [ + "Character", + "\u27e9" + ] + ] + }, + { + "input": "»", + "description": "Named entity: raquo without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "\u00bb" + ] + ] + }, + { + "input": "»", + "description": "Named entity: raquo; with a semi-colon", + "output": [ + [ + "Character", + "\u00bb" + ] + ] + }, + { + "input": "&rarr", + "description": "Bad named entity: rarr without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&rarr" + ] + ] + }, + { + "input": "→", + "description": "Named entity: rarr; with a semi-colon", + "output": [ + [ + "Character", + "\u2192" + ] + ] + }, + { + "input": "&rarrap", + "description": "Bad named entity: rarrap without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&rarrap" + ] + ] + }, + { + "input": "⥵", + "description": "Named entity: rarrap; with a semi-colon", + "output": [ + [ + "Character", + "\u2975" + ] + ] + }, + { + "input": "&rarrb", + "description": "Bad named entity: rarrb without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&rarrb" + ] + ] + }, + { + "input": "⇥", + "description": "Named entity: rarrb; with a semi-colon", + "output": [ + [ + "Character", + "\u21e5" + ] + ] + }, + { + "input": "&rarrbfs", + "description": "Bad named entity: rarrbfs without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&rarrbfs" + ] + ] + }, + { + "input": "⤠", + "description": "Named entity: rarrbfs; with a semi-colon", + "output": [ + [ + "Character", + "\u2920" + ] + ] + }, + { + "input": "&rarrc", + "description": "Bad named entity: rarrc without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&rarrc" + ] + ] + }, + { + "input": "⤳", + "description": "Named entity: rarrc; with a semi-colon", + "output": [ + [ + "Character", + "\u2933" + ] + ] + }, + { + "input": "&rarrfs", + "description": "Bad named entity: rarrfs without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&rarrfs" + ] + ] + }, + { + "input": "⤞", + "description": "Named entity: rarrfs; with a semi-colon", + "output": [ + [ + "Character", + "\u291e" + ] + ] + }, + { + "input": "&rarrhk", + "description": "Bad named entity: rarrhk without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&rarrhk" + ] + ] + }, + { + "input": "↪", + "description": "Named entity: rarrhk; with a semi-colon", + "output": [ + [ + "Character", + "\u21aa" + ] + ] + }, + { + "input": "&rarrlp", + "description": "Bad named entity: rarrlp without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&rarrlp" + ] + ] + }, + { + "input": "↬", + "description": "Named entity: rarrlp; with a semi-colon", + "output": [ + [ + "Character", + "\u21ac" + ] + ] + }, + { + "input": "&rarrpl", + "description": "Bad named entity: rarrpl without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&rarrpl" + ] + ] + }, + { + "input": "⥅", + "description": "Named entity: rarrpl; with a semi-colon", + "output": [ + [ + "Character", + "\u2945" + ] + ] + }, + { + "input": "&rarrsim", + "description": "Bad named entity: rarrsim without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&rarrsim" + ] + ] + }, + { + "input": "⥴", + "description": "Named entity: rarrsim; with a semi-colon", + "output": [ + [ + "Character", + "\u2974" + ] + ] + }, + { + "input": "&rarrtl", + "description": "Bad named entity: rarrtl without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&rarrtl" + ] + ] + }, + { + "input": "↣", + "description": "Named entity: rarrtl; with a semi-colon", + "output": [ + [ + "Character", + "\u21a3" + ] + ] + }, + { + "input": "&rarrw", + "description": "Bad named entity: rarrw without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&rarrw" + ] + ] + }, + { + "input": "↝", + "description": "Named entity: rarrw; with a semi-colon", + "output": [ + [ + "Character", + "\u219d" + ] + ] + }, + { + "input": "&ratail", + "description": "Bad named entity: ratail without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&ratail" + ] + ] + }, + { + "input": "⤚", + "description": "Named entity: ratail; with a semi-colon", + "output": [ + [ + "Character", + "\u291a" + ] + ] + }, + { + "input": "&ratio", + "description": "Bad named entity: ratio without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&ratio" + ] + ] + }, + { + "input": "∶", + "description": "Named entity: ratio; with a semi-colon", + "output": [ + [ + "Character", + "\u2236" + ] + ] + }, + { + "input": "&rationals", + "description": "Bad named entity: rationals without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&rationals" + ] + ] + }, + { + "input": "ℚ", + "description": "Named entity: rationals; with a semi-colon", + "output": [ + [ + "Character", + "\u211a" + ] + ] + }, + { + "input": "&rbarr", + "description": "Bad named entity: rbarr without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&rbarr" + ] + ] + }, + { + "input": "⤍", + "description": "Named entity: rbarr; with a semi-colon", + "output": [ + [ + "Character", + "\u290d" + ] + ] + }, + { + "input": "&rbbrk", + "description": "Bad named entity: rbbrk without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&rbbrk" + ] + ] + }, + { + "input": "❳", + "description": "Named entity: rbbrk; with a semi-colon", + "output": [ + [ + "Character", + "\u2773" + ] + ] + }, + { + "input": "&rbrace", + "description": "Bad named entity: rbrace without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&rbrace" + ] + ] + }, + { + "input": "}", + "description": "Named entity: rbrace; with a semi-colon", + "output": [ + [ + "Character", + "}" + ] + ] + }, + { + "input": "&rbrack", + "description": "Bad named entity: rbrack without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&rbrack" + ] + ] + }, + { + "input": "]", + "description": "Named entity: rbrack; with a semi-colon", + "output": [ + [ + "Character", + "]" + ] + ] + }, + { + "input": "&rbrke", + "description": "Bad named entity: rbrke without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&rbrke" + ] + ] + }, + { + "input": "⦌", + "description": "Named entity: rbrke; with a semi-colon", + "output": [ + [ + "Character", + "\u298c" + ] + ] + }, + { + "input": "&rbrksld", + "description": "Bad named entity: rbrksld without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&rbrksld" + ] + ] + }, + { + "input": "⦎", + "description": "Named entity: rbrksld; with a semi-colon", + "output": [ + [ + "Character", + "\u298e" + ] + ] + }, + { + "input": "&rbrkslu", + "description": "Bad named entity: rbrkslu without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&rbrkslu" + ] + ] + }, + { + "input": "⦐", + "description": "Named entity: rbrkslu; with a semi-colon", + "output": [ + [ + "Character", + "\u2990" + ] + ] + }, + { + "input": "&rcaron", + "description": "Bad named entity: rcaron without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&rcaron" + ] + ] + }, + { + "input": "ř", + "description": "Named entity: rcaron; with a semi-colon", + "output": [ + [ + "Character", + "\u0159" + ] + ] + }, + { + "input": "&rcedil", + "description": "Bad named entity: rcedil without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&rcedil" + ] + ] + }, + { + "input": "ŗ", + "description": "Named entity: rcedil; with a semi-colon", + "output": [ + [ + "Character", + "\u0157" + ] + ] + }, + { + "input": "&rceil", + "description": "Bad named entity: rceil without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&rceil" + ] + ] + }, + { + "input": "⌉", + "description": "Named entity: rceil; with a semi-colon", + "output": [ + [ + "Character", + "\u2309" + ] + ] + }, + { + "input": "&rcub", + "description": "Bad named entity: rcub without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&rcub" + ] + ] + }, + { + "input": "}", + "description": "Named entity: rcub; with a semi-colon", + "output": [ + [ + "Character", + "}" + ] + ] + }, + { + "input": "&rcy", + "description": "Bad named entity: rcy without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&rcy" + ] + ] + }, + { + "input": "р", + "description": "Named entity: rcy; with a semi-colon", + "output": [ + [ + "Character", + "\u0440" + ] + ] + }, + { + "input": "&rdca", + "description": "Bad named entity: rdca without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&rdca" + ] + ] + }, + { + "input": "⤷", + "description": "Named entity: rdca; with a semi-colon", + "output": [ + [ + "Character", + "\u2937" + ] + ] + }, + { + "input": "&rdldhar", + "description": "Bad named entity: rdldhar without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&rdldhar" + ] + ] + }, + { + "input": "⥩", + "description": "Named entity: rdldhar; with a semi-colon", + "output": [ + [ + "Character", + "\u2969" + ] + ] + }, + { + "input": "&rdquo", + "description": "Bad named entity: rdquo without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&rdquo" + ] + ] + }, + { + "input": "”", + "description": "Named entity: rdquo; with a semi-colon", + "output": [ + [ + "Character", + "\u201d" + ] + ] + }, + { + "input": "&rdquor", + "description": "Bad named entity: rdquor without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&rdquor" + ] + ] + }, + { + "input": "”", + "description": "Named entity: rdquor; with a semi-colon", + "output": [ + [ + "Character", + "\u201d" + ] + ] + }, + { + "input": "&rdsh", + "description": "Bad named entity: rdsh without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&rdsh" + ] + ] + }, + { + "input": "↳", + "description": "Named entity: rdsh; with a semi-colon", + "output": [ + [ + "Character", + "\u21b3" + ] + ] + }, + { + "input": "&real", + "description": "Bad named entity: real without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&real" + ] + ] + }, + { + "input": "ℜ", + "description": "Named entity: real; with a semi-colon", + "output": [ + [ + "Character", + "\u211c" + ] + ] + }, + { + "input": "&realine", + "description": "Bad named entity: realine without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&realine" + ] + ] + }, + { + "input": "ℛ", + "description": "Named entity: realine; with a semi-colon", + "output": [ + [ + "Character", + "\u211b" + ] + ] + }, + { + "input": "&realpart", + "description": "Bad named entity: realpart without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&realpart" + ] + ] + }, + { + "input": "ℜ", + "description": "Named entity: realpart; with a semi-colon", + "output": [ + [ + "Character", + "\u211c" + ] + ] + }, + { + "input": "&reals", + "description": "Bad named entity: reals without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&reals" + ] + ] + }, + { + "input": "ℝ", + "description": "Named entity: reals; with a semi-colon", + "output": [ + [ + "Character", + "\u211d" + ] + ] + }, + { + "input": "&rect", + "description": "Bad named entity: rect without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&rect" + ] + ] + }, + { + "input": "▭", + "description": "Named entity: rect; with a semi-colon", + "output": [ + [ + "Character", + "\u25ad" + ] + ] + }, + { + "input": "®", + "description": "Named entity: reg without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "\u00ae" + ] + ] + }, + { + "input": "®", + "description": "Named entity: reg; with a semi-colon", + "output": [ + [ + "Character", + "\u00ae" + ] + ] + }, + { + "input": "&rfisht", + "description": "Bad named entity: rfisht without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&rfisht" + ] + ] + }, + { + "input": "⥽", + "description": "Named entity: rfisht; with a semi-colon", + "output": [ + [ + "Character", + "\u297d" + ] + ] + }, + { + "input": "&rfloor", + "description": "Bad named entity: rfloor without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&rfloor" + ] + ] + }, + { + "input": "⌋", + "description": "Named entity: rfloor; with a semi-colon", + "output": [ + [ + "Character", + "\u230b" + ] + ] + }, + { + "input": "&rfr", + "description": "Bad named entity: rfr without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&rfr" + ] + ] + }, + { + "input": "𝔯", + "description": "Named entity: rfr; with a semi-colon", + "output": [ + [ + "Character", + "\ud835\udd2f" + ] + ] + }, + { + "input": "&rhard", + "description": "Bad named entity: rhard without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&rhard" + ] + ] + }, + { + "input": "⇁", + "description": "Named entity: rhard; with a semi-colon", + "output": [ + [ + "Character", + "\u21c1" + ] + ] + }, + { + "input": "&rharu", + "description": "Bad named entity: rharu without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&rharu" + ] + ] + }, + { + "input": "⇀", + "description": "Named entity: rharu; with a semi-colon", + "output": [ + [ + "Character", + "\u21c0" + ] + ] + }, + { + "input": "&rharul", + "description": "Bad named entity: rharul without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&rharul" + ] + ] + }, + { + "input": "⥬", + "description": "Named entity: rharul; with a semi-colon", + "output": [ + [ + "Character", + "\u296c" + ] + ] + }, + { + "input": "&rho", + "description": "Bad named entity: rho without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&rho" + ] + ] + }, + { + "input": "ρ", + "description": "Named entity: rho; with a semi-colon", + "output": [ + [ + "Character", + "\u03c1" + ] + ] + }, + { + "input": "&rhov", + "description": "Bad named entity: rhov without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&rhov" + ] + ] + }, + { + "input": "ϱ", + "description": "Named entity: rhov; with a semi-colon", + "output": [ + [ + "Character", + "\u03f1" + ] + ] + }, + { + "input": "&rightarrow", + "description": "Bad named entity: rightarrow without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&rightarrow" + ] + ] + }, + { + "input": "→", + "description": "Named entity: rightarrow; with a semi-colon", + "output": [ + [ + "Character", + "\u2192" + ] + ] + }, + { + "input": "&rightarrowtail", + "description": "Bad named entity: rightarrowtail without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&rightarrowtail" + ] + ] + }, + { + "input": "↣", + "description": "Named entity: rightarrowtail; with a semi-colon", + "output": [ + [ + "Character", + "\u21a3" + ] + ] + }, + { + "input": "&rightharpoondown", + "description": "Bad named entity: rightharpoondown without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&rightharpoondown" + ] + ] + }, + { + "input": "⇁", + "description": "Named entity: rightharpoondown; with a semi-colon", + "output": [ + [ + "Character", + "\u21c1" + ] + ] + }, + { + "input": "&rightharpoonup", + "description": "Bad named entity: rightharpoonup without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&rightharpoonup" + ] + ] + }, + { + "input": "⇀", + "description": "Named entity: rightharpoonup; with a semi-colon", + "output": [ + [ + "Character", + "\u21c0" + ] + ] + }, + { + "input": "&rightleftarrows", + "description": "Bad named entity: rightleftarrows without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&rightleftarrows" + ] + ] + }, + { + "input": "⇄", + "description": "Named entity: rightleftarrows; with a semi-colon", + "output": [ + [ + "Character", + "\u21c4" + ] + ] + }, + { + "input": "&rightleftharpoons", + "description": "Bad named entity: rightleftharpoons without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&rightleftharpoons" + ] + ] + }, + { + "input": "⇌", + "description": "Named entity: rightleftharpoons; with a semi-colon", + "output": [ + [ + "Character", + "\u21cc" + ] + ] + }, + { + "input": "&rightrightarrows", + "description": "Bad named entity: rightrightarrows without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&rightrightarrows" + ] + ] + }, + { + "input": "⇉", + "description": "Named entity: rightrightarrows; with a semi-colon", + "output": [ + [ + "Character", + "\u21c9" + ] + ] + }, + { + "input": "&rightsquigarrow", + "description": "Bad named entity: rightsquigarrow without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&rightsquigarrow" + ] + ] + }, + { + "input": "↝", + "description": "Named entity: rightsquigarrow; with a semi-colon", + "output": [ + [ + "Character", + "\u219d" + ] + ] + }, + { + "input": "&rightthreetimes", + "description": "Bad named entity: rightthreetimes without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&rightthreetimes" + ] + ] + }, + { + "input": "⋌", + "description": "Named entity: rightthreetimes; with a semi-colon", + "output": [ + [ + "Character", + "\u22cc" + ] + ] + }, + { + "input": "&ring", + "description": "Bad named entity: ring without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&ring" + ] + ] + }, + { + "input": "˚", + "description": "Named entity: ring; with a semi-colon", + "output": [ + [ + "Character", + "\u02da" + ] + ] + }, + { + "input": "&risingdotseq", + "description": "Bad named entity: risingdotseq without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&risingdotseq" + ] + ] + }, + { + "input": "≓", + "description": "Named entity: risingdotseq; with a semi-colon", + "output": [ + [ + "Character", + "\u2253" + ] + ] + }, + { + "input": "&rlarr", + "description": "Bad named entity: rlarr without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&rlarr" + ] + ] + }, + { + "input": "⇄", + "description": "Named entity: rlarr; with a semi-colon", + "output": [ + [ + "Character", + "\u21c4" + ] + ] + }, + { + "input": "&rlhar", + "description": "Bad named entity: rlhar without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&rlhar" + ] + ] + }, + { + "input": "⇌", + "description": "Named entity: rlhar; with a semi-colon", + "output": [ + [ + "Character", + "\u21cc" + ] + ] + }, + { + "input": "&rlm", + "description": "Bad named entity: rlm without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&rlm" + ] + ] + }, + { + "input": "‏", + "description": "Named entity: rlm; with a semi-colon", + "output": [ + [ + "Character", + "\u200f" + ] + ] + }, + { + "input": "&rmoust", + "description": "Bad named entity: rmoust without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&rmoust" + ] + ] + }, + { + "input": "⎱", + "description": "Named entity: rmoust; with a semi-colon", + "output": [ + [ + "Character", + "\u23b1" + ] + ] + }, + { + "input": "&rmoustache", + "description": "Bad named entity: rmoustache without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&rmoustache" + ] + ] + }, + { + "input": "⎱", + "description": "Named entity: rmoustache; with a semi-colon", + "output": [ + [ + "Character", + "\u23b1" + ] + ] + }, + { + "input": "&rnmid", + "description": "Bad named entity: rnmid without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&rnmid" + ] + ] + }, + { + "input": "⫮", + "description": "Named entity: rnmid; with a semi-colon", + "output": [ + [ + "Character", + "\u2aee" + ] + ] + }, + { + "input": "&roang", + "description": "Bad named entity: roang without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&roang" + ] + ] + }, + { + "input": "⟭", + "description": "Named entity: roang; with a semi-colon", + "output": [ + [ + "Character", + "\u27ed" + ] + ] + }, + { + "input": "&roarr", + "description": "Bad named entity: roarr without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&roarr" + ] + ] + }, + { + "input": "⇾", + "description": "Named entity: roarr; with a semi-colon", + "output": [ + [ + "Character", + "\u21fe" + ] + ] + }, + { + "input": "&robrk", + "description": "Bad named entity: robrk without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&robrk" + ] + ] + }, + { + "input": "⟧", + "description": "Named entity: robrk; with a semi-colon", + "output": [ + [ + "Character", + "\u27e7" + ] + ] + }, + { + "input": "&ropar", + "description": "Bad named entity: ropar without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&ropar" + ] + ] + }, + { + "input": "⦆", + "description": "Named entity: ropar; with a semi-colon", + "output": [ + [ + "Character", + "\u2986" + ] + ] + }, + { + "input": "&ropf", + "description": "Bad named entity: ropf without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&ropf" + ] + ] + }, + { + "input": "𝕣", + "description": "Named entity: ropf; with a semi-colon", + "output": [ + [ + "Character", + "\ud835\udd63" + ] + ] + }, + { + "input": "&roplus", + "description": "Bad named entity: roplus without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&roplus" + ] + ] + }, + { + "input": "⨮", + "description": "Named entity: roplus; with a semi-colon", + "output": [ + [ + "Character", + "\u2a2e" + ] + ] + }, + { + "input": "&rotimes", + "description": "Bad named entity: rotimes without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&rotimes" + ] + ] + }, + { + "input": "⨵", + "description": "Named entity: rotimes; with a semi-colon", + "output": [ + [ + "Character", + "\u2a35" + ] + ] + }, + { + "input": "&rpar", + "description": "Bad named entity: rpar without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&rpar" + ] + ] + }, + { + "input": ")", + "description": "Named entity: rpar; with a semi-colon", + "output": [ + [ + "Character", + ")" + ] + ] + }, + { + "input": "&rpargt", + "description": "Bad named entity: rpargt without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&rpargt" + ] + ] + }, + { + "input": "⦔", + "description": "Named entity: rpargt; with a semi-colon", + "output": [ + [ + "Character", + "\u2994" + ] + ] + }, + { + "input": "&rppolint", + "description": "Bad named entity: rppolint without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&rppolint" + ] + ] + }, + { + "input": "⨒", + "description": "Named entity: rppolint; with a semi-colon", + "output": [ + [ + "Character", + "\u2a12" + ] + ] + }, + { + "input": "&rrarr", + "description": "Bad named entity: rrarr without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&rrarr" + ] + ] + }, + { + "input": "⇉", + "description": "Named entity: rrarr; with a semi-colon", + "output": [ + [ + "Character", + "\u21c9" + ] + ] + }, + { + "input": "&rsaquo", + "description": "Bad named entity: rsaquo without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&rsaquo" + ] + ] + }, + { + "input": "›", + "description": "Named entity: rsaquo; with a semi-colon", + "output": [ + [ + "Character", + "\u203a" + ] + ] + }, + { + "input": "&rscr", + "description": "Bad named entity: rscr without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&rscr" + ] + ] + }, + { + "input": "𝓇", + "description": "Named entity: rscr; with a semi-colon", + "output": [ + [ + "Character", + "\ud835\udcc7" + ] + ] + }, + { + "input": "&rsh", + "description": "Bad named entity: rsh without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&rsh" + ] + ] + }, + { + "input": "↱", + "description": "Named entity: rsh; with a semi-colon", + "output": [ + [ + "Character", + "\u21b1" + ] + ] + }, + { + "input": "&rsqb", + "description": "Bad named entity: rsqb without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&rsqb" + ] + ] + }, + { + "input": "]", + "description": "Named entity: rsqb; with a semi-colon", + "output": [ + [ + "Character", + "]" + ] + ] + }, + { + "input": "&rsquo", + "description": "Bad named entity: rsquo without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&rsquo" + ] + ] + }, + { + "input": "’", + "description": "Named entity: rsquo; with a semi-colon", + "output": [ + [ + "Character", + "\u2019" + ] + ] + }, + { + "input": "&rsquor", + "description": "Bad named entity: rsquor without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&rsquor" + ] + ] + }, + { + "input": "’", + "description": "Named entity: rsquor; with a semi-colon", + "output": [ + [ + "Character", + "\u2019" + ] + ] + }, + { + "input": "&rthree", + "description": "Bad named entity: rthree without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&rthree" + ] + ] + }, + { + "input": "⋌", + "description": "Named entity: rthree; with a semi-colon", + "output": [ + [ + "Character", + "\u22cc" + ] + ] + }, + { + "input": "&rtimes", + "description": "Bad named entity: rtimes without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&rtimes" + ] + ] + }, + { + "input": "⋊", + "description": "Named entity: rtimes; with a semi-colon", + "output": [ + [ + "Character", + "\u22ca" + ] + ] + }, + { + "input": "&rtri", + "description": "Bad named entity: rtri without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&rtri" + ] + ] + }, + { + "input": "▹", + "description": "Named entity: rtri; with a semi-colon", + "output": [ + [ + "Character", + "\u25b9" + ] + ] + }, + { + "input": "&rtrie", + "description": "Bad named entity: rtrie without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&rtrie" + ] + ] + }, + { + "input": "⊵", + "description": "Named entity: rtrie; with a semi-colon", + "output": [ + [ + "Character", + "\u22b5" + ] + ] + }, + { + "input": "&rtrif", + "description": "Bad named entity: rtrif without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&rtrif" + ] + ] + }, + { + "input": "▸", + "description": "Named entity: rtrif; with a semi-colon", + "output": [ + [ + "Character", + "\u25b8" + ] + ] + }, + { + "input": "&rtriltri", + "description": "Bad named entity: rtriltri without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&rtriltri" + ] + ] + }, + { + "input": "⧎", + "description": "Named entity: rtriltri; with a semi-colon", + "output": [ + [ + "Character", + "\u29ce" + ] + ] + }, + { + "input": "&ruluhar", + "description": "Bad named entity: ruluhar without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&ruluhar" + ] + ] + }, + { + "input": "⥨", + "description": "Named entity: ruluhar; with a semi-colon", + "output": [ + [ + "Character", + "\u2968" + ] + ] + }, + { + "input": "&rx", + "description": "Bad named entity: rx without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&rx" + ] + ] + }, + { + "input": "℞", + "description": "Named entity: rx; with a semi-colon", + "output": [ + [ + "Character", + "\u211e" + ] + ] + }, + { + "input": "&sacute", + "description": "Bad named entity: sacute without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&sacute" + ] + ] + }, + { + "input": "ś", + "description": "Named entity: sacute; with a semi-colon", + "output": [ + [ + "Character", + "\u015b" + ] + ] + }, + { + "input": "&sbquo", + "description": "Bad named entity: sbquo without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&sbquo" + ] + ] + }, + { + "input": "‚", + "description": "Named entity: sbquo; with a semi-colon", + "output": [ + [ + "Character", + "\u201a" + ] + ] + }, + { + "input": "&sc", + "description": "Bad named entity: sc without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&sc" + ] + ] + }, + { + "input": "≻", + "description": "Named entity: sc; with a semi-colon", + "output": [ + [ + "Character", + "\u227b" + ] + ] + }, + { + "input": "&scE", + "description": "Bad named entity: scE without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&scE" + ] + ] + }, + { + "input": "⪴", + "description": "Named entity: scE; with a semi-colon", + "output": [ + [ + "Character", + "\u2ab4" + ] + ] + }, + { + "input": "&scap", + "description": "Bad named entity: scap without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&scap" + ] + ] + }, + { + "input": "⪸", + "description": "Named entity: scap; with a semi-colon", + "output": [ + [ + "Character", + "\u2ab8" + ] + ] + }, + { + "input": "&scaron", + "description": "Bad named entity: scaron without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&scaron" + ] + ] + }, + { + "input": "š", + "description": "Named entity: scaron; with a semi-colon", + "output": [ + [ + "Character", + "\u0161" + ] + ] + }, + { + "input": "&sccue", + "description": "Bad named entity: sccue without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&sccue" + ] + ] + }, + { + "input": "≽", + "description": "Named entity: sccue; with a semi-colon", + "output": [ + [ + "Character", + "\u227d" + ] + ] + }, + { + "input": "&sce", + "description": "Bad named entity: sce without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&sce" + ] + ] + }, + { + "input": "⪰", + "description": "Named entity: sce; with a semi-colon", + "output": [ + [ + "Character", + "\u2ab0" + ] + ] + }, + { + "input": "&scedil", + "description": "Bad named entity: scedil without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&scedil" + ] + ] + }, + { + "input": "ş", + "description": "Named entity: scedil; with a semi-colon", + "output": [ + [ + "Character", + "\u015f" + ] + ] + }, + { + "input": "&scirc", + "description": "Bad named entity: scirc without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&scirc" + ] + ] + }, + { + "input": "ŝ", + "description": "Named entity: scirc; with a semi-colon", + "output": [ + [ + "Character", + "\u015d" + ] + ] + }, + { + "input": "&scnE", + "description": "Bad named entity: scnE without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&scnE" + ] + ] + }, + { + "input": "⪶", + "description": "Named entity: scnE; with a semi-colon", + "output": [ + [ + "Character", + "\u2ab6" + ] + ] + }, + { + "input": "&scnap", + "description": "Bad named entity: scnap without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&scnap" + ] + ] + }, + { + "input": "⪺", + "description": "Named entity: scnap; with a semi-colon", + "output": [ + [ + "Character", + "\u2aba" + ] + ] + }, + { + "input": "&scnsim", + "description": "Bad named entity: scnsim without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&scnsim" + ] + ] + }, + { + "input": "⋩", + "description": "Named entity: scnsim; with a semi-colon", + "output": [ + [ + "Character", + "\u22e9" + ] + ] + }, + { + "input": "&scpolint", + "description": "Bad named entity: scpolint without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&scpolint" + ] + ] + }, + { + "input": "⨓", + "description": "Named entity: scpolint; with a semi-colon", + "output": [ + [ + "Character", + "\u2a13" + ] + ] + }, + { + "input": "&scsim", + "description": "Bad named entity: scsim without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&scsim" + ] + ] + }, + { + "input": "≿", + "description": "Named entity: scsim; with a semi-colon", + "output": [ + [ + "Character", + "\u227f" + ] + ] + }, + { + "input": "&scy", + "description": "Bad named entity: scy without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&scy" + ] + ] + }, + { + "input": "с", + "description": "Named entity: scy; with a semi-colon", + "output": [ + [ + "Character", + "\u0441" + ] + ] + }, + { + "input": "&sdot", + "description": "Bad named entity: sdot without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&sdot" + ] + ] + }, + { + "input": "⋅", + "description": "Named entity: sdot; with a semi-colon", + "output": [ + [ + "Character", + "\u22c5" + ] + ] + }, + { + "input": "&sdotb", + "description": "Bad named entity: sdotb without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&sdotb" + ] + ] + }, + { + "input": "⊡", + "description": "Named entity: sdotb; with a semi-colon", + "output": [ + [ + "Character", + "\u22a1" + ] + ] + }, + { + "input": "&sdote", + "description": "Bad named entity: sdote without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&sdote" + ] + ] + }, + { + "input": "⩦", + "description": "Named entity: sdote; with a semi-colon", + "output": [ + [ + "Character", + "\u2a66" + ] + ] + }, + { + "input": "&seArr", + "description": "Bad named entity: seArr without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&seArr" + ] + ] + }, + { + "input": "⇘", + "description": "Named entity: seArr; with a semi-colon", + "output": [ + [ + "Character", + "\u21d8" + ] + ] + }, + { + "input": "&searhk", + "description": "Bad named entity: searhk without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&searhk" + ] + ] + }, + { + "input": "⤥", + "description": "Named entity: searhk; with a semi-colon", + "output": [ + [ + "Character", + "\u2925" + ] + ] + }, + { + "input": "&searr", + "description": "Bad named entity: searr without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&searr" + ] + ] + }, + { + "input": "↘", + "description": "Named entity: searr; with a semi-colon", + "output": [ + [ + "Character", + "\u2198" + ] + ] + }, + { + "input": "&searrow", + "description": "Bad named entity: searrow without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&searrow" + ] + ] + }, + { + "input": "↘", + "description": "Named entity: searrow; with a semi-colon", + "output": [ + [ + "Character", + "\u2198" + ] + ] + }, + { + "input": "§", + "description": "Named entity: sect without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "\u00a7" + ] + ] + }, + { + "input": "§", + "description": "Named entity: sect; with a semi-colon", + "output": [ + [ + "Character", + "\u00a7" + ] + ] + }, + { + "input": "&semi", + "description": "Bad named entity: semi without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&semi" + ] + ] + }, + { + "input": ";", + "description": "Named entity: semi; with a semi-colon", + "output": [ + [ + "Character", + ";" + ] + ] + }, + { + "input": "&seswar", + "description": "Bad named entity: seswar without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&seswar" + ] + ] + }, + { + "input": "⤩", + "description": "Named entity: seswar; with a semi-colon", + "output": [ + [ + "Character", + "\u2929" + ] + ] + }, + { + "input": "&setminus", + "description": "Bad named entity: setminus without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&setminus" + ] + ] + }, + { + "input": "∖", + "description": "Named entity: setminus; with a semi-colon", + "output": [ + [ + "Character", + "\u2216" + ] + ] + }, + { + "input": "&setmn", + "description": "Bad named entity: setmn without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&setmn" + ] + ] + }, + { + "input": "∖", + "description": "Named entity: setmn; with a semi-colon", + "output": [ + [ + "Character", + "\u2216" + ] + ] + }, + { + "input": "&sext", + "description": "Bad named entity: sext without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&sext" + ] + ] + }, + { + "input": "✶", + "description": "Named entity: sext; with a semi-colon", + "output": [ + [ + "Character", + "\u2736" + ] + ] + }, + { + "input": "&sfr", + "description": "Bad named entity: sfr without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&sfr" + ] + ] + }, + { + "input": "𝔰", + "description": "Named entity: sfr; with a semi-colon", + "output": [ + [ + "Character", + "\ud835\udd30" + ] + ] + }, + { + "input": "&sfrown", + "description": "Bad named entity: sfrown without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&sfrown" + ] + ] + }, + { + "input": "⌢", + "description": "Named entity: sfrown; with a semi-colon", + "output": [ + [ + "Character", + "\u2322" + ] + ] + }, + { + "input": "&sharp", + "description": "Bad named entity: sharp without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&sharp" + ] + ] + }, + { + "input": "♯", + "description": "Named entity: sharp; with a semi-colon", + "output": [ + [ + "Character", + "\u266f" + ] + ] + }, + { + "input": "&shchcy", + "description": "Bad named entity: shchcy without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&shchcy" + ] + ] + }, + { + "input": "щ", + "description": "Named entity: shchcy; with a semi-colon", + "output": [ + [ + "Character", + "\u0449" + ] + ] + }, + { + "input": "&shcy", + "description": "Bad named entity: shcy without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&shcy" + ] + ] + }, + { + "input": "ш", + "description": "Named entity: shcy; with a semi-colon", + "output": [ + [ + "Character", + "\u0448" + ] + ] + }, + { + "input": "&shortmid", + "description": "Bad named entity: shortmid without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&shortmid" + ] + ] + }, + { + "input": "∣", + "description": "Named entity: shortmid; with a semi-colon", + "output": [ + [ + "Character", + "\u2223" + ] + ] + }, + { + "input": "&shortparallel", + "description": "Bad named entity: shortparallel without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&shortparallel" + ] + ] + }, + { + "input": "∥", + "description": "Named entity: shortparallel; with a semi-colon", + "output": [ + [ + "Character", + "\u2225" + ] + ] + }, + { + "input": "­", + "description": "Named entity: shy without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "\u00ad" + ] + ] + }, + { + "input": "­", + "description": "Named entity: shy; with a semi-colon", + "output": [ + [ + "Character", + "\u00ad" + ] + ] + }, + { + "input": "&sigma", + "description": "Bad named entity: sigma without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&sigma" + ] + ] + }, + { + "input": "σ", + "description": "Named entity: sigma; with a semi-colon", + "output": [ + [ + "Character", + "\u03c3" + ] + ] + }, + { + "input": "&sigmaf", + "description": "Bad named entity: sigmaf without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&sigmaf" + ] + ] + }, + { + "input": "ς", + "description": "Named entity: sigmaf; with a semi-colon", + "output": [ + [ + "Character", + "\u03c2" + ] + ] + }, + { + "input": "&sigmav", + "description": "Bad named entity: sigmav without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&sigmav" + ] + ] + }, + { + "input": "ς", + "description": "Named entity: sigmav; with a semi-colon", + "output": [ + [ + "Character", + "\u03c2" + ] + ] + }, + { + "input": "&sim", + "description": "Bad named entity: sim without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&sim" + ] + ] + }, + { + "input": "∼", + "description": "Named entity: sim; with a semi-colon", + "output": [ + [ + "Character", + "\u223c" + ] + ] + }, + { + "input": "&simdot", + "description": "Bad named entity: simdot without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&simdot" + ] + ] + }, + { + "input": "⩪", + "description": "Named entity: simdot; with a semi-colon", + "output": [ + [ + "Character", + "\u2a6a" + ] + ] + }, + { + "input": "&sime", + "description": "Bad named entity: sime without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&sime" + ] + ] + }, + { + "input": "≃", + "description": "Named entity: sime; with a semi-colon", + "output": [ + [ + "Character", + "\u2243" + ] + ] + }, + { + "input": "&simeq", + "description": "Bad named entity: simeq without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&simeq" + ] + ] + }, + { + "input": "≃", + "description": "Named entity: simeq; with a semi-colon", + "output": [ + [ + "Character", + "\u2243" + ] + ] + }, + { + "input": "&simg", + "description": "Bad named entity: simg without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&simg" + ] + ] + }, + { + "input": "⪞", + "description": "Named entity: simg; with a semi-colon", + "output": [ + [ + "Character", + "\u2a9e" + ] + ] + }, + { + "input": "&simgE", + "description": "Bad named entity: simgE without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&simgE" + ] + ] + }, + { + "input": "⪠", + "description": "Named entity: simgE; with a semi-colon", + "output": [ + [ + "Character", + "\u2aa0" + ] + ] + }, + { + "input": "&siml", + "description": "Bad named entity: siml without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&siml" + ] + ] + }, + { + "input": "⪝", + "description": "Named entity: siml; with a semi-colon", + "output": [ + [ + "Character", + "\u2a9d" + ] + ] + }, + { + "input": "&simlE", + "description": "Bad named entity: simlE without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&simlE" + ] + ] + }, + { + "input": "⪟", + "description": "Named entity: simlE; with a semi-colon", + "output": [ + [ + "Character", + "\u2a9f" + ] + ] + }, + { + "input": "&simne", + "description": "Bad named entity: simne without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&simne" + ] + ] + }, + { + "input": "≆", + "description": "Named entity: simne; with a semi-colon", + "output": [ + [ + "Character", + "\u2246" + ] + ] + }, + { + "input": "&simplus", + "description": "Bad named entity: simplus without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&simplus" + ] + ] + }, + { + "input": "⨤", + "description": "Named entity: simplus; with a semi-colon", + "output": [ + [ + "Character", + "\u2a24" + ] + ] + }, + { + "input": "&simrarr", + "description": "Bad named entity: simrarr without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&simrarr" + ] + ] + }, + { + "input": "⥲", + "description": "Named entity: simrarr; with a semi-colon", + "output": [ + [ + "Character", + "\u2972" + ] + ] + }, + { + "input": "&slarr", + "description": "Bad named entity: slarr without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&slarr" + ] + ] + }, + { + "input": "←", + "description": "Named entity: slarr; with a semi-colon", + "output": [ + [ + "Character", + "\u2190" + ] + ] + }, + { + "input": "&smallsetminus", + "description": "Bad named entity: smallsetminus without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&smallsetminus" + ] + ] + }, + { + "input": "∖", + "description": "Named entity: smallsetminus; with a semi-colon", + "output": [ + [ + "Character", + "\u2216" + ] + ] + }, + { + "input": "&smashp", + "description": "Bad named entity: smashp without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&smashp" + ] + ] + }, + { + "input": "⨳", + "description": "Named entity: smashp; with a semi-colon", + "output": [ + [ + "Character", + "\u2a33" + ] + ] + }, + { + "input": "&smeparsl", + "description": "Bad named entity: smeparsl without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&smeparsl" + ] + ] + }, + { + "input": "⧤", + "description": "Named entity: smeparsl; with a semi-colon", + "output": [ + [ + "Character", + "\u29e4" + ] + ] + }, + { + "input": "&smid", + "description": "Bad named entity: smid without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&smid" + ] + ] + }, + { + "input": "∣", + "description": "Named entity: smid; with a semi-colon", + "output": [ + [ + "Character", + "\u2223" + ] + ] + }, + { + "input": "&smile", + "description": "Bad named entity: smile without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&smile" + ] + ] + }, + { + "input": "⌣", + "description": "Named entity: smile; with a semi-colon", + "output": [ + [ + "Character", + "\u2323" + ] + ] + }, + { + "input": "&smt", + "description": "Bad named entity: smt without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&smt" + ] + ] + }, + { + "input": "⪪", + "description": "Named entity: smt; with a semi-colon", + "output": [ + [ + "Character", + "\u2aaa" + ] + ] + }, + { + "input": "&smte", + "description": "Bad named entity: smte without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&smte" + ] + ] + }, + { + "input": "⪬", + "description": "Named entity: smte; with a semi-colon", + "output": [ + [ + "Character", + "\u2aac" + ] + ] + }, + { + "input": "&smtes", + "description": "Bad named entity: smtes without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&smtes" + ] + ] + }, + { + "input": "⪬︀", + "description": "Named entity: smtes; with a semi-colon", + "output": [ + [ + "Character", + "\u2aac\ufe00" + ] + ] + }, + { + "input": "&softcy", + "description": "Bad named entity: softcy without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&softcy" + ] + ] + }, + { + "input": "ь", + "description": "Named entity: softcy; with a semi-colon", + "output": [ + [ + "Character", + "\u044c" + ] + ] + }, + { + "input": "&sol", + "description": "Bad named entity: sol without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&sol" + ] + ] + }, + { + "input": "/", + "description": "Named entity: sol; with a semi-colon", + "output": [ + [ + "Character", + "/" + ] + ] + }, + { + "input": "&solb", + "description": "Bad named entity: solb without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&solb" + ] + ] + }, + { + "input": "⧄", + "description": "Named entity: solb; with a semi-colon", + "output": [ + [ + "Character", + "\u29c4" + ] + ] + }, + { + "input": "&solbar", + "description": "Bad named entity: solbar without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&solbar" + ] + ] + }, + { + "input": "⌿", + "description": "Named entity: solbar; with a semi-colon", + "output": [ + [ + "Character", + "\u233f" + ] + ] + }, + { + "input": "&sopf", + "description": "Bad named entity: sopf without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&sopf" + ] + ] + }, + { + "input": "𝕤", + "description": "Named entity: sopf; with a semi-colon", + "output": [ + [ + "Character", + "\ud835\udd64" + ] + ] + }, + { + "input": "&spades", + "description": "Bad named entity: spades without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&spades" + ] + ] + }, + { + "input": "♠", + "description": "Named entity: spades; with a semi-colon", + "output": [ + [ + "Character", + "\u2660" + ] + ] + }, + { + "input": "&spadesuit", + "description": "Bad named entity: spadesuit without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&spadesuit" + ] + ] + }, + { + "input": "♠", + "description": "Named entity: spadesuit; with a semi-colon", + "output": [ + [ + "Character", + "\u2660" + ] + ] + }, + { + "input": "&spar", + "description": "Bad named entity: spar without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&spar" + ] + ] + }, + { + "input": "∥", + "description": "Named entity: spar; with a semi-colon", + "output": [ + [ + "Character", + "\u2225" + ] + ] + }, + { + "input": "&sqcap", + "description": "Bad named entity: sqcap without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&sqcap" + ] + ] + }, + { + "input": "⊓", + "description": "Named entity: sqcap; with a semi-colon", + "output": [ + [ + "Character", + "\u2293" + ] + ] + }, + { + "input": "&sqcaps", + "description": "Bad named entity: sqcaps without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&sqcaps" + ] + ] + }, + { + "input": "⊓︀", + "description": "Named entity: sqcaps; with a semi-colon", + "output": [ + [ + "Character", + "\u2293\ufe00" + ] + ] + }, + { + "input": "&sqcup", + "description": "Bad named entity: sqcup without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&sqcup" + ] + ] + }, + { + "input": "⊔", + "description": "Named entity: sqcup; with a semi-colon", + "output": [ + [ + "Character", + "\u2294" + ] + ] + }, + { + "input": "&sqcups", + "description": "Bad named entity: sqcups without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&sqcups" + ] + ] + }, + { + "input": "⊔︀", + "description": "Named entity: sqcups; with a semi-colon", + "output": [ + [ + "Character", + "\u2294\ufe00" + ] + ] + }, + { + "input": "&sqsub", + "description": "Bad named entity: sqsub without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&sqsub" + ] + ] + }, + { + "input": "⊏", + "description": "Named entity: sqsub; with a semi-colon", + "output": [ + [ + "Character", + "\u228f" + ] + ] + }, + { + "input": "&sqsube", + "description": "Bad named entity: sqsube without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&sqsube" + ] + ] + }, + { + "input": "⊑", + "description": "Named entity: sqsube; with a semi-colon", + "output": [ + [ + "Character", + "\u2291" + ] + ] + }, + { + "input": "&sqsubset", + "description": "Bad named entity: sqsubset without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&sqsubset" + ] + ] + }, + { + "input": "⊏", + "description": "Named entity: sqsubset; with a semi-colon", + "output": [ + [ + "Character", + "\u228f" + ] + ] + }, + { + "input": "&sqsubseteq", + "description": "Bad named entity: sqsubseteq without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&sqsubseteq" + ] + ] + }, + { + "input": "⊑", + "description": "Named entity: sqsubseteq; with a semi-colon", + "output": [ + [ + "Character", + "\u2291" + ] + ] + }, + { + "input": "&sqsup", + "description": "Bad named entity: sqsup without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&sqsup" + ] + ] + }, + { + "input": "⊐", + "description": "Named entity: sqsup; with a semi-colon", + "output": [ + [ + "Character", + "\u2290" + ] + ] + }, + { + "input": "&sqsupe", + "description": "Bad named entity: sqsupe without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&sqsupe" + ] + ] + }, + { + "input": "⊒", + "description": "Named entity: sqsupe; with a semi-colon", + "output": [ + [ + "Character", + "\u2292" + ] + ] + }, + { + "input": "&sqsupset", + "description": "Bad named entity: sqsupset without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&sqsupset" + ] + ] + }, + { + "input": "⊐", + "description": "Named entity: sqsupset; with a semi-colon", + "output": [ + [ + "Character", + "\u2290" + ] + ] + }, + { + "input": "&sqsupseteq", + "description": "Bad named entity: sqsupseteq without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&sqsupseteq" + ] + ] + }, + { + "input": "⊒", + "description": "Named entity: sqsupseteq; with a semi-colon", + "output": [ + [ + "Character", + "\u2292" + ] + ] + }, + { + "input": "&squ", + "description": "Bad named entity: squ without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&squ" + ] + ] + }, + { + "input": "□", + "description": "Named entity: squ; with a semi-colon", + "output": [ + [ + "Character", + "\u25a1" + ] + ] + }, + { + "input": "&square", + "description": "Bad named entity: square without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&square" + ] + ] + }, + { + "input": "□", + "description": "Named entity: square; with a semi-colon", + "output": [ + [ + "Character", + "\u25a1" + ] + ] + }, + { + "input": "&squarf", + "description": "Bad named entity: squarf without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&squarf" + ] + ] + }, + { + "input": "▪", + "description": "Named entity: squarf; with a semi-colon", + "output": [ + [ + "Character", + "\u25aa" + ] + ] + }, + { + "input": "&squf", + "description": "Bad named entity: squf without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&squf" + ] + ] + }, + { + "input": "▪", + "description": "Named entity: squf; with a semi-colon", + "output": [ + [ + "Character", + "\u25aa" + ] + ] + }, + { + "input": "&srarr", + "description": "Bad named entity: srarr without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&srarr" + ] + ] + }, + { + "input": "→", + "description": "Named entity: srarr; with a semi-colon", + "output": [ + [ + "Character", + "\u2192" + ] + ] + }, + { + "input": "&sscr", + "description": "Bad named entity: sscr without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&sscr" + ] + ] + }, + { + "input": "𝓈", + "description": "Named entity: sscr; with a semi-colon", + "output": [ + [ + "Character", + "\ud835\udcc8" + ] + ] + }, + { + "input": "&ssetmn", + "description": "Bad named entity: ssetmn without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&ssetmn" + ] + ] + }, + { + "input": "∖", + "description": "Named entity: ssetmn; with a semi-colon", + "output": [ + [ + "Character", + "\u2216" + ] + ] + }, + { + "input": "&ssmile", + "description": "Bad named entity: ssmile without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&ssmile" + ] + ] + }, + { + "input": "⌣", + "description": "Named entity: ssmile; with a semi-colon", + "output": [ + [ + "Character", + "\u2323" + ] + ] + }, + { + "input": "&sstarf", + "description": "Bad named entity: sstarf without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&sstarf" + ] + ] + }, + { + "input": "⋆", + "description": "Named entity: sstarf; with a semi-colon", + "output": [ + [ + "Character", + "\u22c6" + ] + ] + }, + { + "input": "&star", + "description": "Bad named entity: star without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&star" + ] + ] + }, + { + "input": "☆", + "description": "Named entity: star; with a semi-colon", + "output": [ + [ + "Character", + "\u2606" + ] + ] + }, + { + "input": "&starf", + "description": "Bad named entity: starf without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&starf" + ] + ] + }, + { + "input": "★", + "description": "Named entity: starf; with a semi-colon", + "output": [ + [ + "Character", + "\u2605" + ] + ] + }, + { + "input": "&straightepsilon", + "description": "Bad named entity: straightepsilon without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&straightepsilon" + ] + ] + }, + { + "input": "ϵ", + "description": "Named entity: straightepsilon; with a semi-colon", + "output": [ + [ + "Character", + "\u03f5" + ] + ] + }, + { + "input": "&straightphi", + "description": "Bad named entity: straightphi without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&straightphi" + ] + ] + }, + { + "input": "ϕ", + "description": "Named entity: straightphi; with a semi-colon", + "output": [ + [ + "Character", + "\u03d5" + ] + ] + }, + { + "input": "&strns", + "description": "Bad named entity: strns without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&strns" + ] + ] + }, + { + "input": "¯", + "description": "Named entity: strns; with a semi-colon", + "output": [ + [ + "Character", + "\u00af" + ] + ] + }, + { + "input": "&sub", + "description": "Bad named entity: sub without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&sub" + ] + ] + }, + { + "input": "⊂", + "description": "Named entity: sub; with a semi-colon", + "output": [ + [ + "Character", + "\u2282" + ] + ] + }, + { + "input": "&subE", + "description": "Bad named entity: subE without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&subE" + ] + ] + }, + { + "input": "⫅", + "description": "Named entity: subE; with a semi-colon", + "output": [ + [ + "Character", + "\u2ac5" + ] + ] + }, + { + "input": "&subdot", + "description": "Bad named entity: subdot without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&subdot" + ] + ] + }, + { + "input": "⪽", + "description": "Named entity: subdot; with a semi-colon", + "output": [ + [ + "Character", + "\u2abd" + ] + ] + }, + { + "input": "&sube", + "description": "Bad named entity: sube without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&sube" + ] + ] + }, + { + "input": "⊆", + "description": "Named entity: sube; with a semi-colon", + "output": [ + [ + "Character", + "\u2286" + ] + ] + }, + { + "input": "&subedot", + "description": "Bad named entity: subedot without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&subedot" + ] + ] + }, + { + "input": "⫃", + "description": "Named entity: subedot; with a semi-colon", + "output": [ + [ + "Character", + "\u2ac3" + ] + ] + }, + { + "input": "&submult", + "description": "Bad named entity: submult without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&submult" + ] + ] + }, + { + "input": "⫁", + "description": "Named entity: submult; with a semi-colon", + "output": [ + [ + "Character", + "\u2ac1" + ] + ] + }, + { + "input": "&subnE", + "description": "Bad named entity: subnE without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&subnE" + ] + ] + }, + { + "input": "⫋", + "description": "Named entity: subnE; with a semi-colon", + "output": [ + [ + "Character", + "\u2acb" + ] + ] + }, + { + "input": "&subne", + "description": "Bad named entity: subne without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&subne" + ] + ] + }, + { + "input": "⊊", + "description": "Named entity: subne; with a semi-colon", + "output": [ + [ + "Character", + "\u228a" + ] + ] + }, + { + "input": "&subplus", + "description": "Bad named entity: subplus without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&subplus" + ] + ] + }, + { + "input": "⪿", + "description": "Named entity: subplus; with a semi-colon", + "output": [ + [ + "Character", + "\u2abf" + ] + ] + }, + { + "input": "&subrarr", + "description": "Bad named entity: subrarr without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&subrarr" + ] + ] + }, + { + "input": "⥹", + "description": "Named entity: subrarr; with a semi-colon", + "output": [ + [ + "Character", + "\u2979" + ] + ] + }, + { + "input": "&subset", + "description": "Bad named entity: subset without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&subset" + ] + ] + }, + { + "input": "⊂", + "description": "Named entity: subset; with a semi-colon", + "output": [ + [ + "Character", + "\u2282" + ] + ] + }, + { + "input": "&subseteq", + "description": "Bad named entity: subseteq without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&subseteq" + ] + ] + }, + { + "input": "⊆", + "description": "Named entity: subseteq; with a semi-colon", + "output": [ + [ + "Character", + "\u2286" + ] + ] + }, + { + "input": "&subseteqq", + "description": "Bad named entity: subseteqq without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&subseteqq" + ] + ] + }, + { + "input": "⫅", + "description": "Named entity: subseteqq; with a semi-colon", + "output": [ + [ + "Character", + "\u2ac5" + ] + ] + }, + { + "input": "&subsetneq", + "description": "Bad named entity: subsetneq without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&subsetneq" + ] + ] + }, + { + "input": "⊊", + "description": "Named entity: subsetneq; with a semi-colon", + "output": [ + [ + "Character", + "\u228a" + ] + ] + }, + { + "input": "&subsetneqq", + "description": "Bad named entity: subsetneqq without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&subsetneqq" + ] + ] + }, + { + "input": "⫋", + "description": "Named entity: subsetneqq; with a semi-colon", + "output": [ + [ + "Character", + "\u2acb" + ] + ] + }, + { + "input": "&subsim", + "description": "Bad named entity: subsim without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&subsim" + ] + ] + }, + { + "input": "⫇", + "description": "Named entity: subsim; with a semi-colon", + "output": [ + [ + "Character", + "\u2ac7" + ] + ] + }, + { + "input": "&subsub", + "description": "Bad named entity: subsub without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&subsub" + ] + ] + }, + { + "input": "⫕", + "description": "Named entity: subsub; with a semi-colon", + "output": [ + [ + "Character", + "\u2ad5" + ] + ] + }, + { + "input": "&subsup", + "description": "Bad named entity: subsup without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&subsup" + ] + ] + }, + { + "input": "⫓", + "description": "Named entity: subsup; with a semi-colon", + "output": [ + [ + "Character", + "\u2ad3" + ] + ] + }, + { + "input": "&succ", + "description": "Bad named entity: succ without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&succ" + ] + ] + }, + { + "input": "≻", + "description": "Named entity: succ; with a semi-colon", + "output": [ + [ + "Character", + "\u227b" + ] + ] + }, + { + "input": "&succapprox", + "description": "Bad named entity: succapprox without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&succapprox" + ] + ] + }, + { + "input": "⪸", + "description": "Named entity: succapprox; with a semi-colon", + "output": [ + [ + "Character", + "\u2ab8" + ] + ] + }, + { + "input": "&succcurlyeq", + "description": "Bad named entity: succcurlyeq without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&succcurlyeq" + ] + ] + }, + { + "input": "≽", + "description": "Named entity: succcurlyeq; with a semi-colon", + "output": [ + [ + "Character", + "\u227d" + ] + ] + }, + { + "input": "&succeq", + "description": "Bad named entity: succeq without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&succeq" + ] + ] + }, + { + "input": "⪰", + "description": "Named entity: succeq; with a semi-colon", + "output": [ + [ + "Character", + "\u2ab0" + ] + ] + }, + { + "input": "&succnapprox", + "description": "Bad named entity: succnapprox without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&succnapprox" + ] + ] + }, + { + "input": "⪺", + "description": "Named entity: succnapprox; with a semi-colon", + "output": [ + [ + "Character", + "\u2aba" + ] + ] + }, + { + "input": "&succneqq", + "description": "Bad named entity: succneqq without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&succneqq" + ] + ] + }, + { + "input": "⪶", + "description": "Named entity: succneqq; with a semi-colon", + "output": [ + [ + "Character", + "\u2ab6" + ] + ] + }, + { + "input": "&succnsim", + "description": "Bad named entity: succnsim without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&succnsim" + ] + ] + }, + { + "input": "⋩", + "description": "Named entity: succnsim; with a semi-colon", + "output": [ + [ + "Character", + "\u22e9" + ] + ] + }, + { + "input": "&succsim", + "description": "Bad named entity: succsim without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&succsim" + ] + ] + }, + { + "input": "≿", + "description": "Named entity: succsim; with a semi-colon", + "output": [ + [ + "Character", + "\u227f" + ] + ] + }, + { + "input": "&sum", + "description": "Bad named entity: sum without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&sum" + ] + ] + }, + { + "input": "∑", + "description": "Named entity: sum; with a semi-colon", + "output": [ + [ + "Character", + "\u2211" + ] + ] + }, + { + "input": "&sung", + "description": "Bad named entity: sung without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&sung" + ] + ] + }, + { + "input": "♪", + "description": "Named entity: sung; with a semi-colon", + "output": [ + [ + "Character", + "\u266a" + ] + ] + }, + { + "input": "&sup", + "description": "Bad named entity: sup without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&sup" + ] + ] + }, + { + "input": "¹", + "description": "Named entity: sup1 without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "\u00b9" + ] + ] + }, + { + "input": "¹", + "description": "Named entity: sup1; with a semi-colon", + "output": [ + [ + "Character", + "\u00b9" + ] + ] + }, + { + "input": "²", + "description": "Named entity: sup2 without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "\u00b2" + ] + ] + }, + { + "input": "²", + "description": "Named entity: sup2; with a semi-colon", + "output": [ + [ + "Character", + "\u00b2" + ] + ] + }, + { + "input": "³", + "description": "Named entity: sup3 without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "\u00b3" + ] + ] + }, + { + "input": "³", + "description": "Named entity: sup3; with a semi-colon", + "output": [ + [ + "Character", + "\u00b3" + ] + ] + }, + { + "input": "⊃", + "description": "Named entity: sup; with a semi-colon", + "output": [ + [ + "Character", + "\u2283" + ] + ] + }, + { + "input": "&supE", + "description": "Bad named entity: supE without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&supE" + ] + ] + }, + { + "input": "⫆", + "description": "Named entity: supE; with a semi-colon", + "output": [ + [ + "Character", + "\u2ac6" + ] + ] + }, + { + "input": "&supdot", + "description": "Bad named entity: supdot without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&supdot" + ] + ] + }, + { + "input": "⪾", + "description": "Named entity: supdot; with a semi-colon", + "output": [ + [ + "Character", + "\u2abe" + ] + ] + }, + { + "input": "&supdsub", + "description": "Bad named entity: supdsub without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&supdsub" + ] + ] + }, + { + "input": "⫘", + "description": "Named entity: supdsub; with a semi-colon", + "output": [ + [ + "Character", + "\u2ad8" + ] + ] + }, + { + "input": "&supe", + "description": "Bad named entity: supe without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&supe" + ] + ] + }, + { + "input": "⊇", + "description": "Named entity: supe; with a semi-colon", + "output": [ + [ + "Character", + "\u2287" + ] + ] + }, + { + "input": "&supedot", + "description": "Bad named entity: supedot without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&supedot" + ] + ] + }, + { + "input": "⫄", + "description": "Named entity: supedot; with a semi-colon", + "output": [ + [ + "Character", + "\u2ac4" + ] + ] + }, + { + "input": "&suphsol", + "description": "Bad named entity: suphsol without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&suphsol" + ] + ] + }, + { + "input": "⟉", + "description": "Named entity: suphsol; with a semi-colon", + "output": [ + [ + "Character", + "\u27c9" + ] + ] + }, + { + "input": "&suphsub", + "description": "Bad named entity: suphsub without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&suphsub" + ] + ] + }, + { + "input": "⫗", + "description": "Named entity: suphsub; with a semi-colon", + "output": [ + [ + "Character", + "\u2ad7" + ] + ] + }, + { + "input": "&suplarr", + "description": "Bad named entity: suplarr without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&suplarr" + ] + ] + }, + { + "input": "⥻", + "description": "Named entity: suplarr; with a semi-colon", + "output": [ + [ + "Character", + "\u297b" + ] + ] + }, + { + "input": "&supmult", + "description": "Bad named entity: supmult without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&supmult" + ] + ] + }, + { + "input": "⫂", + "description": "Named entity: supmult; with a semi-colon", + "output": [ + [ + "Character", + "\u2ac2" + ] + ] + }, + { + "input": "&supnE", + "description": "Bad named entity: supnE without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&supnE" + ] + ] + }, + { + "input": "⫌", + "description": "Named entity: supnE; with a semi-colon", + "output": [ + [ + "Character", + "\u2acc" + ] + ] + }, + { + "input": "&supne", + "description": "Bad named entity: supne without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&supne" + ] + ] + }, + { + "input": "⊋", + "description": "Named entity: supne; with a semi-colon", + "output": [ + [ + "Character", + "\u228b" + ] + ] + }, + { + "input": "&supplus", + "description": "Bad named entity: supplus without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&supplus" + ] + ] + }, + { + "input": "⫀", + "description": "Named entity: supplus; with a semi-colon", + "output": [ + [ + "Character", + "\u2ac0" + ] + ] + }, + { + "input": "&supset", + "description": "Bad named entity: supset without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&supset" + ] + ] + }, + { + "input": "⊃", + "description": "Named entity: supset; with a semi-colon", + "output": [ + [ + "Character", + "\u2283" + ] + ] + }, + { + "input": "&supseteq", + "description": "Bad named entity: supseteq without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&supseteq" + ] + ] + }, + { + "input": "⊇", + "description": "Named entity: supseteq; with a semi-colon", + "output": [ + [ + "Character", + "\u2287" + ] + ] + }, + { + "input": "&supseteqq", + "description": "Bad named entity: supseteqq without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&supseteqq" + ] + ] + }, + { + "input": "⫆", + "description": "Named entity: supseteqq; with a semi-colon", + "output": [ + [ + "Character", + "\u2ac6" + ] + ] + }, + { + "input": "&supsetneq", + "description": "Bad named entity: supsetneq without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&supsetneq" + ] + ] + }, + { + "input": "⊋", + "description": "Named entity: supsetneq; with a semi-colon", + "output": [ + [ + "Character", + "\u228b" + ] + ] + }, + { + "input": "&supsetneqq", + "description": "Bad named entity: supsetneqq without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&supsetneqq" + ] + ] + }, + { + "input": "⫌", + "description": "Named entity: supsetneqq; with a semi-colon", + "output": [ + [ + "Character", + "\u2acc" + ] + ] + }, + { + "input": "&supsim", + "description": "Bad named entity: supsim without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&supsim" + ] + ] + }, + { + "input": "⫈", + "description": "Named entity: supsim; with a semi-colon", + "output": [ + [ + "Character", + "\u2ac8" + ] + ] + }, + { + "input": "&supsub", + "description": "Bad named entity: supsub without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&supsub" + ] + ] + }, + { + "input": "⫔", + "description": "Named entity: supsub; with a semi-colon", + "output": [ + [ + "Character", + "\u2ad4" + ] + ] + }, + { + "input": "&supsup", + "description": "Bad named entity: supsup without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&supsup" + ] + ] + }, + { + "input": "⫖", + "description": "Named entity: supsup; with a semi-colon", + "output": [ + [ + "Character", + "\u2ad6" + ] + ] + }, + { + "input": "&swArr", + "description": "Bad named entity: swArr without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&swArr" + ] + ] + }, + { + "input": "⇙", + "description": "Named entity: swArr; with a semi-colon", + "output": [ + [ + "Character", + "\u21d9" + ] + ] + }, + { + "input": "&swarhk", + "description": "Bad named entity: swarhk without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&swarhk" + ] + ] + }, + { + "input": "⤦", + "description": "Named entity: swarhk; with a semi-colon", + "output": [ + [ + "Character", + "\u2926" + ] + ] + }, + { + "input": "&swarr", + "description": "Bad named entity: swarr without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&swarr" + ] + ] + }, + { + "input": "↙", + "description": "Named entity: swarr; with a semi-colon", + "output": [ + [ + "Character", + "\u2199" + ] + ] + }, + { + "input": "&swarrow", + "description": "Bad named entity: swarrow without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&swarrow" + ] + ] + }, + { + "input": "↙", + "description": "Named entity: swarrow; with a semi-colon", + "output": [ + [ + "Character", + "\u2199" + ] + ] + }, + { + "input": "&swnwar", + "description": "Bad named entity: swnwar without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&swnwar" + ] + ] + }, + { + "input": "⤪", + "description": "Named entity: swnwar; with a semi-colon", + "output": [ + [ + "Character", + "\u292a" + ] + ] + }, + { + "input": "ß", + "description": "Named entity: szlig without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "\u00df" + ] + ] + }, + { + "input": "ß", + "description": "Named entity: szlig; with a semi-colon", + "output": [ + [ + "Character", + "\u00df" + ] + ] + }, + { + "input": "&target", + "description": "Bad named entity: target without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&target" + ] + ] + }, + { + "input": "⌖", + "description": "Named entity: target; with a semi-colon", + "output": [ + [ + "Character", + "\u2316" + ] + ] + }, + { + "input": "&tau", + "description": "Bad named entity: tau without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&tau" + ] + ] + }, + { + "input": "τ", + "description": "Named entity: tau; with a semi-colon", + "output": [ + [ + "Character", + "\u03c4" + ] + ] + }, + { + "input": "&tbrk", + "description": "Bad named entity: tbrk without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&tbrk" + ] + ] + }, + { + "input": "⎴", + "description": "Named entity: tbrk; with a semi-colon", + "output": [ + [ + "Character", + "\u23b4" + ] + ] + }, + { + "input": "&tcaron", + "description": "Bad named entity: tcaron without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&tcaron" + ] + ] + }, + { + "input": "ť", + "description": "Named entity: tcaron; with a semi-colon", + "output": [ + [ + "Character", + "\u0165" + ] + ] + }, + { + "input": "&tcedil", + "description": "Bad named entity: tcedil without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&tcedil" + ] + ] + }, + { + "input": "ţ", + "description": "Named entity: tcedil; with a semi-colon", + "output": [ + [ + "Character", + "\u0163" + ] + ] + }, + { + "input": "&tcy", + "description": "Bad named entity: tcy without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&tcy" + ] + ] + }, + { + "input": "т", + "description": "Named entity: tcy; with a semi-colon", + "output": [ + [ + "Character", + "\u0442" + ] + ] + }, + { + "input": "&tdot", + "description": "Bad named entity: tdot without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&tdot" + ] + ] + }, + { + "input": "⃛", + "description": "Named entity: tdot; with a semi-colon", + "output": [ + [ + "Character", + "\u20db" + ] + ] + }, + { + "input": "&telrec", + "description": "Bad named entity: telrec without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&telrec" + ] + ] + }, + { + "input": "⌕", + "description": "Named entity: telrec; with a semi-colon", + "output": [ + [ + "Character", + "\u2315" + ] + ] + }, + { + "input": "&tfr", + "description": "Bad named entity: tfr without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&tfr" + ] + ] + }, + { + "input": "𝔱", + "description": "Named entity: tfr; with a semi-colon", + "output": [ + [ + "Character", + "\ud835\udd31" + ] + ] + }, + { + "input": "&there4", + "description": "Bad named entity: there4 without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&there4" + ] + ] + }, + { + "input": "∴", + "description": "Named entity: there4; with a semi-colon", + "output": [ + [ + "Character", + "\u2234" + ] + ] + }, + { + "input": "&therefore", + "description": "Bad named entity: therefore without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&therefore" + ] + ] + }, + { + "input": "∴", + "description": "Named entity: therefore; with a semi-colon", + "output": [ + [ + "Character", + "\u2234" + ] + ] + }, + { + "input": "&theta", + "description": "Bad named entity: theta without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&theta" + ] + ] + }, + { + "input": "θ", + "description": "Named entity: theta; with a semi-colon", + "output": [ + [ + "Character", + "\u03b8" + ] + ] + }, + { + "input": "&thetasym", + "description": "Bad named entity: thetasym without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&thetasym" + ] + ] + }, + { + "input": "ϑ", + "description": "Named entity: thetasym; with a semi-colon", + "output": [ + [ + "Character", + "\u03d1" + ] + ] + }, + { + "input": "&thetav", + "description": "Bad named entity: thetav without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&thetav" + ] + ] + }, + { + "input": "ϑ", + "description": "Named entity: thetav; with a semi-colon", + "output": [ + [ + "Character", + "\u03d1" + ] + ] + }, + { + "input": "&thickapprox", + "description": "Bad named entity: thickapprox without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&thickapprox" + ] + ] + }, + { + "input": "≈", + "description": "Named entity: thickapprox; with a semi-colon", + "output": [ + [ + "Character", + "\u2248" + ] + ] + }, + { + "input": "&thicksim", + "description": "Bad named entity: thicksim without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&thicksim" + ] + ] + }, + { + "input": "∼", + "description": "Named entity: thicksim; with a semi-colon", + "output": [ + [ + "Character", + "\u223c" + ] + ] + }, + { + "input": "&thinsp", + "description": "Bad named entity: thinsp without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&thinsp" + ] + ] + }, + { + "input": " ", + "description": "Named entity: thinsp; with a semi-colon", + "output": [ + [ + "Character", + "\u2009" + ] + ] + }, + { + "input": "&thkap", + "description": "Bad named entity: thkap without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&thkap" + ] + ] + }, + { + "input": "≈", + "description": "Named entity: thkap; with a semi-colon", + "output": [ + [ + "Character", + "\u2248" + ] + ] + }, + { + "input": "&thksim", + "description": "Bad named entity: thksim without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&thksim" + ] + ] + }, + { + "input": "∼", + "description": "Named entity: thksim; with a semi-colon", + "output": [ + [ + "Character", + "\u223c" + ] + ] + }, + { + "input": "þ", + "description": "Named entity: thorn without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "\u00fe" + ] + ] + }, + { + "input": "þ", + "description": "Named entity: thorn; with a semi-colon", + "output": [ + [ + "Character", + "\u00fe" + ] + ] + }, + { + "input": "&tilde", + "description": "Bad named entity: tilde without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&tilde" + ] + ] + }, + { + "input": "˜", + "description": "Named entity: tilde; with a semi-colon", + "output": [ + [ + "Character", + "\u02dc" + ] + ] + }, + { + "input": "×", + "description": "Named entity: times without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "\u00d7" + ] + ] + }, + { + "input": "×", + "description": "Named entity: times; with a semi-colon", + "output": [ + [ + "Character", + "\u00d7" + ] + ] + }, + { + "input": "⊠", + "description": "Named entity: timesb; with a semi-colon", + "output": [ + [ + "Character", + "\u22a0" + ] + ] + }, + { + "input": "⨱", + "description": "Named entity: timesbar; with a semi-colon", + "output": [ + [ + "Character", + "\u2a31" + ] + ] + }, + { + "input": "⨰", + "description": "Named entity: timesd; with a semi-colon", + "output": [ + [ + "Character", + "\u2a30" + ] + ] + }, + { + "input": "&tint", + "description": "Bad named entity: tint without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&tint" + ] + ] + }, + { + "input": "∭", + "description": "Named entity: tint; with a semi-colon", + "output": [ + [ + "Character", + "\u222d" + ] + ] + }, + { + "input": "&toea", + "description": "Bad named entity: toea without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&toea" + ] + ] + }, + { + "input": "⤨", + "description": "Named entity: toea; with a semi-colon", + "output": [ + [ + "Character", + "\u2928" + ] + ] + }, + { + "input": "&top", + "description": "Bad named entity: top without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&top" + ] + ] + }, + { + "input": "⊤", + "description": "Named entity: top; with a semi-colon", + "output": [ + [ + "Character", + "\u22a4" + ] + ] + }, + { + "input": "&topbot", + "description": "Bad named entity: topbot without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&topbot" + ] + ] + }, + { + "input": "⌶", + "description": "Named entity: topbot; with a semi-colon", + "output": [ + [ + "Character", + "\u2336" + ] + ] + }, + { + "input": "&topcir", + "description": "Bad named entity: topcir without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&topcir" + ] + ] + }, + { + "input": "⫱", + "description": "Named entity: topcir; with a semi-colon", + "output": [ + [ + "Character", + "\u2af1" + ] + ] + }, + { + "input": "&topf", + "description": "Bad named entity: topf without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&topf" + ] + ] + }, + { + "input": "𝕥", + "description": "Named entity: topf; with a semi-colon", + "output": [ + [ + "Character", + "\ud835\udd65" + ] + ] + }, + { + "input": "&topfork", + "description": "Bad named entity: topfork without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&topfork" + ] + ] + }, + { + "input": "⫚", + "description": "Named entity: topfork; with a semi-colon", + "output": [ + [ + "Character", + "\u2ada" + ] + ] + }, + { + "input": "&tosa", + "description": "Bad named entity: tosa without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&tosa" + ] + ] + }, + { + "input": "⤩", + "description": "Named entity: tosa; with a semi-colon", + "output": [ + [ + "Character", + "\u2929" + ] + ] + }, + { + "input": "&tprime", + "description": "Bad named entity: tprime without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&tprime" + ] + ] + }, + { + "input": "‴", + "description": "Named entity: tprime; with a semi-colon", + "output": [ + [ + "Character", + "\u2034" + ] + ] + }, + { + "input": "&trade", + "description": "Bad named entity: trade without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&trade" + ] + ] + }, + { + "input": "™", + "description": "Named entity: trade; with a semi-colon", + "output": [ + [ + "Character", + "\u2122" + ] + ] + }, + { + "input": "&triangle", + "description": "Bad named entity: triangle without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&triangle" + ] + ] + }, + { + "input": "▵", + "description": "Named entity: triangle; with a semi-colon", + "output": [ + [ + "Character", + "\u25b5" + ] + ] + }, + { + "input": "&triangledown", + "description": "Bad named entity: triangledown without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&triangledown" + ] + ] + }, + { + "input": "▿", + "description": "Named entity: triangledown; with a semi-colon", + "output": [ + [ + "Character", + "\u25bf" + ] + ] + }, + { + "input": "&triangleleft", + "description": "Bad named entity: triangleleft without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&triangleleft" + ] + ] + }, + { + "input": "◃", + "description": "Named entity: triangleleft; with a semi-colon", + "output": [ + [ + "Character", + "\u25c3" + ] + ] + }, + { + "input": "&trianglelefteq", + "description": "Bad named entity: trianglelefteq without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&trianglelefteq" + ] + ] + }, + { + "input": "⊴", + "description": "Named entity: trianglelefteq; with a semi-colon", + "output": [ + [ + "Character", + "\u22b4" + ] + ] + }, + { + "input": "&triangleq", + "description": "Bad named entity: triangleq without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&triangleq" + ] + ] + }, + { + "input": "≜", + "description": "Named entity: triangleq; with a semi-colon", + "output": [ + [ + "Character", + "\u225c" + ] + ] + }, + { + "input": "&triangleright", + "description": "Bad named entity: triangleright without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&triangleright" + ] + ] + }, + { + "input": "▹", + "description": "Named entity: triangleright; with a semi-colon", + "output": [ + [ + "Character", + "\u25b9" + ] + ] + }, + { + "input": "&trianglerighteq", + "description": "Bad named entity: trianglerighteq without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&trianglerighteq" + ] + ] + }, + { + "input": "⊵", + "description": "Named entity: trianglerighteq; with a semi-colon", + "output": [ + [ + "Character", + "\u22b5" + ] + ] + }, + { + "input": "&tridot", + "description": "Bad named entity: tridot without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&tridot" + ] + ] + }, + { + "input": "◬", + "description": "Named entity: tridot; with a semi-colon", + "output": [ + [ + "Character", + "\u25ec" + ] + ] + }, + { + "input": "&trie", + "description": "Bad named entity: trie without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&trie" + ] + ] + }, + { + "input": "≜", + "description": "Named entity: trie; with a semi-colon", + "output": [ + [ + "Character", + "\u225c" + ] + ] + }, + { + "input": "&triminus", + "description": "Bad named entity: triminus without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&triminus" + ] + ] + }, + { + "input": "⨺", + "description": "Named entity: triminus; with a semi-colon", + "output": [ + [ + "Character", + "\u2a3a" + ] + ] + }, + { + "input": "&triplus", + "description": "Bad named entity: triplus without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&triplus" + ] + ] + }, + { + "input": "⨹", + "description": "Named entity: triplus; with a semi-colon", + "output": [ + [ + "Character", + "\u2a39" + ] + ] + }, + { + "input": "&trisb", + "description": "Bad named entity: trisb without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&trisb" + ] + ] + }, + { + "input": "⧍", + "description": "Named entity: trisb; with a semi-colon", + "output": [ + [ + "Character", + "\u29cd" + ] + ] + }, + { + "input": "&tritime", + "description": "Bad named entity: tritime without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&tritime" + ] + ] + }, + { + "input": "⨻", + "description": "Named entity: tritime; with a semi-colon", + "output": [ + [ + "Character", + "\u2a3b" + ] + ] + }, + { + "input": "&trpezium", + "description": "Bad named entity: trpezium without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&trpezium" + ] + ] + }, + { + "input": "⏢", + "description": "Named entity: trpezium; with a semi-colon", + "output": [ + [ + "Character", + "\u23e2" + ] + ] + }, + { + "input": "&tscr", + "description": "Bad named entity: tscr without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&tscr" + ] + ] + }, + { + "input": "𝓉", + "description": "Named entity: tscr; with a semi-colon", + "output": [ + [ + "Character", + "\ud835\udcc9" + ] + ] + }, + { + "input": "&tscy", + "description": "Bad named entity: tscy without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&tscy" + ] + ] + }, + { + "input": "ц", + "description": "Named entity: tscy; with a semi-colon", + "output": [ + [ + "Character", + "\u0446" + ] + ] + }, + { + "input": "&tshcy", + "description": "Bad named entity: tshcy without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&tshcy" + ] + ] + }, + { + "input": "ћ", + "description": "Named entity: tshcy; with a semi-colon", + "output": [ + [ + "Character", + "\u045b" + ] + ] + }, + { + "input": "&tstrok", + "description": "Bad named entity: tstrok without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&tstrok" + ] + ] + }, + { + "input": "ŧ", + "description": "Named entity: tstrok; with a semi-colon", + "output": [ + [ + "Character", + "\u0167" + ] + ] + }, + { + "input": "&twixt", + "description": "Bad named entity: twixt without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&twixt" + ] + ] + }, + { + "input": "≬", + "description": "Named entity: twixt; with a semi-colon", + "output": [ + [ + "Character", + "\u226c" + ] + ] + }, + { + "input": "&twoheadleftarrow", + "description": "Bad named entity: twoheadleftarrow without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&twoheadleftarrow" + ] + ] + }, + { + "input": "↞", + "description": "Named entity: twoheadleftarrow; with a semi-colon", + "output": [ + [ + "Character", + "\u219e" + ] + ] + }, + { + "input": "&twoheadrightarrow", + "description": "Bad named entity: twoheadrightarrow without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&twoheadrightarrow" + ] + ] + }, + { + "input": "↠", + "description": "Named entity: twoheadrightarrow; with a semi-colon", + "output": [ + [ + "Character", + "\u21a0" + ] + ] + }, + { + "input": "&uArr", + "description": "Bad named entity: uArr without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&uArr" + ] + ] + }, + { + "input": "⇑", + "description": "Named entity: uArr; with a semi-colon", + "output": [ + [ + "Character", + "\u21d1" + ] + ] + }, + { + "input": "&uHar", + "description": "Bad named entity: uHar without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&uHar" + ] + ] + }, + { + "input": "⥣", + "description": "Named entity: uHar; with a semi-colon", + "output": [ + [ + "Character", + "\u2963" + ] + ] + }, + { + "input": "ú", + "description": "Named entity: uacute without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "\u00fa" + ] + ] + }, + { + "input": "ú", + "description": "Named entity: uacute; with a semi-colon", + "output": [ + [ + "Character", + "\u00fa" + ] + ] + }, + { + "input": "&uarr", + "description": "Bad named entity: uarr without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&uarr" + ] + ] + }, + { + "input": "↑", + "description": "Named entity: uarr; with a semi-colon", + "output": [ + [ + "Character", + "\u2191" + ] + ] + }, + { + "input": "&ubrcy", + "description": "Bad named entity: ubrcy without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&ubrcy" + ] + ] + }, + { + "input": "ў", + "description": "Named entity: ubrcy; with a semi-colon", + "output": [ + [ + "Character", + "\u045e" + ] + ] + }, + { + "input": "&ubreve", + "description": "Bad named entity: ubreve without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&ubreve" + ] + ] + }, + { + "input": "ŭ", + "description": "Named entity: ubreve; with a semi-colon", + "output": [ + [ + "Character", + "\u016d" + ] + ] + }, + { + "input": "û", + "description": "Named entity: ucirc without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "\u00fb" + ] + ] + }, + { + "input": "û", + "description": "Named entity: ucirc; with a semi-colon", + "output": [ + [ + "Character", + "\u00fb" + ] + ] + }, + { + "input": "&ucy", + "description": "Bad named entity: ucy without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&ucy" + ] + ] + }, + { + "input": "у", + "description": "Named entity: ucy; with a semi-colon", + "output": [ + [ + "Character", + "\u0443" + ] + ] + }, + { + "input": "&udarr", + "description": "Bad named entity: udarr without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&udarr" + ] + ] + }, + { + "input": "⇅", + "description": "Named entity: udarr; with a semi-colon", + "output": [ + [ + "Character", + "\u21c5" + ] + ] + }, + { + "input": "&udblac", + "description": "Bad named entity: udblac without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&udblac" + ] + ] + }, + { + "input": "ű", + "description": "Named entity: udblac; with a semi-colon", + "output": [ + [ + "Character", + "\u0171" + ] + ] + }, + { + "input": "&udhar", + "description": "Bad named entity: udhar without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&udhar" + ] + ] + }, + { + "input": "⥮", + "description": "Named entity: udhar; with a semi-colon", + "output": [ + [ + "Character", + "\u296e" + ] + ] + }, + { + "input": "&ufisht", + "description": "Bad named entity: ufisht without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&ufisht" + ] + ] + }, + { + "input": "⥾", + "description": "Named entity: ufisht; with a semi-colon", + "output": [ + [ + "Character", + "\u297e" + ] + ] + }, + { + "input": "&ufr", + "description": "Bad named entity: ufr without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&ufr" + ] + ] + }, + { + "input": "𝔲", + "description": "Named entity: ufr; with a semi-colon", + "output": [ + [ + "Character", + "\ud835\udd32" + ] + ] + }, + { + "input": "ù", + "description": "Named entity: ugrave without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "\u00f9" + ] + ] + }, + { + "input": "ù", + "description": "Named entity: ugrave; with a semi-colon", + "output": [ + [ + "Character", + "\u00f9" + ] + ] + }, + { + "input": "&uharl", + "description": "Bad named entity: uharl without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&uharl" + ] + ] + }, + { + "input": "↿", + "description": "Named entity: uharl; with a semi-colon", + "output": [ + [ + "Character", + "\u21bf" + ] + ] + }, + { + "input": "&uharr", + "description": "Bad named entity: uharr without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&uharr" + ] + ] + }, + { + "input": "↾", + "description": "Named entity: uharr; with a semi-colon", + "output": [ + [ + "Character", + "\u21be" + ] + ] + }, + { + "input": "&uhblk", + "description": "Bad named entity: uhblk without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&uhblk" + ] + ] + }, + { + "input": "▀", + "description": "Named entity: uhblk; with a semi-colon", + "output": [ + [ + "Character", + "\u2580" + ] + ] + }, + { + "input": "&ulcorn", + "description": "Bad named entity: ulcorn without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&ulcorn" + ] + ] + }, + { + "input": "⌜", + "description": "Named entity: ulcorn; with a semi-colon", + "output": [ + [ + "Character", + "\u231c" + ] + ] + }, + { + "input": "&ulcorner", + "description": "Bad named entity: ulcorner without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&ulcorner" + ] + ] + }, + { + "input": "⌜", + "description": "Named entity: ulcorner; with a semi-colon", + "output": [ + [ + "Character", + "\u231c" + ] + ] + }, + { + "input": "&ulcrop", + "description": "Bad named entity: ulcrop without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&ulcrop" + ] + ] + }, + { + "input": "⌏", + "description": "Named entity: ulcrop; with a semi-colon", + "output": [ + [ + "Character", + "\u230f" + ] + ] + }, + { + "input": "&ultri", + "description": "Bad named entity: ultri without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&ultri" + ] + ] + }, + { + "input": "◸", + "description": "Named entity: ultri; with a semi-colon", + "output": [ + [ + "Character", + "\u25f8" + ] + ] + }, + { + "input": "&umacr", + "description": "Bad named entity: umacr without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&umacr" + ] + ] + }, + { + "input": "ū", + "description": "Named entity: umacr; with a semi-colon", + "output": [ + [ + "Character", + "\u016b" + ] + ] + }, + { + "input": "¨", + "description": "Named entity: uml without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "\u00a8" + ] + ] + }, + { + "input": "¨", + "description": "Named entity: uml; with a semi-colon", + "output": [ + [ + "Character", + "\u00a8" + ] + ] + }, + { + "input": "&uogon", + "description": "Bad named entity: uogon without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&uogon" + ] + ] + }, + { + "input": "ų", + "description": "Named entity: uogon; with a semi-colon", + "output": [ + [ + "Character", + "\u0173" + ] + ] + }, + { + "input": "&uopf", + "description": "Bad named entity: uopf without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&uopf" + ] + ] + }, + { + "input": "𝕦", + "description": "Named entity: uopf; with a semi-colon", + "output": [ + [ + "Character", + "\ud835\udd66" + ] + ] + }, + { + "input": "&uparrow", + "description": "Bad named entity: uparrow without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&uparrow" + ] + ] + }, + { + "input": "↑", + "description": "Named entity: uparrow; with a semi-colon", + "output": [ + [ + "Character", + "\u2191" + ] + ] + }, + { + "input": "&updownarrow", + "description": "Bad named entity: updownarrow without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&updownarrow" + ] + ] + }, + { + "input": "↕", + "description": "Named entity: updownarrow; with a semi-colon", + "output": [ + [ + "Character", + "\u2195" + ] + ] + }, + { + "input": "&upharpoonleft", + "description": "Bad named entity: upharpoonleft without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&upharpoonleft" + ] + ] + }, + { + "input": "↿", + "description": "Named entity: upharpoonleft; with a semi-colon", + "output": [ + [ + "Character", + "\u21bf" + ] + ] + }, + { + "input": "&upharpoonright", + "description": "Bad named entity: upharpoonright without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&upharpoonright" + ] + ] + }, + { + "input": "↾", + "description": "Named entity: upharpoonright; with a semi-colon", + "output": [ + [ + "Character", + "\u21be" + ] + ] + }, + { + "input": "&uplus", + "description": "Bad named entity: uplus without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&uplus" + ] + ] + }, + { + "input": "⊎", + "description": "Named entity: uplus; with a semi-colon", + "output": [ + [ + "Character", + "\u228e" + ] + ] + }, + { + "input": "&upsi", + "description": "Bad named entity: upsi without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&upsi" + ] + ] + }, + { + "input": "υ", + "description": "Named entity: upsi; with a semi-colon", + "output": [ + [ + "Character", + "\u03c5" + ] + ] + }, + { + "input": "&upsih", + "description": "Bad named entity: upsih without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&upsih" + ] + ] + }, + { + "input": "ϒ", + "description": "Named entity: upsih; with a semi-colon", + "output": [ + [ + "Character", + "\u03d2" + ] + ] + }, + { + "input": "&upsilon", + "description": "Bad named entity: upsilon without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&upsilon" + ] + ] + }, + { + "input": "υ", + "description": "Named entity: upsilon; with a semi-colon", + "output": [ + [ + "Character", + "\u03c5" + ] + ] + }, + { + "input": "&upuparrows", + "description": "Bad named entity: upuparrows without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&upuparrows" + ] + ] + }, + { + "input": "⇈", + "description": "Named entity: upuparrows; with a semi-colon", + "output": [ + [ + "Character", + "\u21c8" + ] + ] + }, + { + "input": "&urcorn", + "description": "Bad named entity: urcorn without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&urcorn" + ] + ] + }, + { + "input": "⌝", + "description": "Named entity: urcorn; with a semi-colon", + "output": [ + [ + "Character", + "\u231d" + ] + ] + }, + { + "input": "&urcorner", + "description": "Bad named entity: urcorner without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&urcorner" + ] + ] + }, + { + "input": "⌝", + "description": "Named entity: urcorner; with a semi-colon", + "output": [ + [ + "Character", + "\u231d" + ] + ] + }, + { + "input": "&urcrop", + "description": "Bad named entity: urcrop without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&urcrop" + ] + ] + }, + { + "input": "⌎", + "description": "Named entity: urcrop; with a semi-colon", + "output": [ + [ + "Character", + "\u230e" + ] + ] + }, + { + "input": "&uring", + "description": "Bad named entity: uring without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&uring" + ] + ] + }, + { + "input": "ů", + "description": "Named entity: uring; with a semi-colon", + "output": [ + [ + "Character", + "\u016f" + ] + ] + }, + { + "input": "&urtri", + "description": "Bad named entity: urtri without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&urtri" + ] + ] + }, + { + "input": "◹", + "description": "Named entity: urtri; with a semi-colon", + "output": [ + [ + "Character", + "\u25f9" + ] + ] + }, + { + "input": "&uscr", + "description": "Bad named entity: uscr without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&uscr" + ] + ] + }, + { + "input": "𝓊", + "description": "Named entity: uscr; with a semi-colon", + "output": [ + [ + "Character", + "\ud835\udcca" + ] + ] + }, + { + "input": "&utdot", + "description": "Bad named entity: utdot without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&utdot" + ] + ] + }, + { + "input": "⋰", + "description": "Named entity: utdot; with a semi-colon", + "output": [ + [ + "Character", + "\u22f0" + ] + ] + }, + { + "input": "&utilde", + "description": "Bad named entity: utilde without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&utilde" + ] + ] + }, + { + "input": "ũ", + "description": "Named entity: utilde; with a semi-colon", + "output": [ + [ + "Character", + "\u0169" + ] + ] + }, + { + "input": "&utri", + "description": "Bad named entity: utri without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&utri" + ] + ] + }, + { + "input": "▵", + "description": "Named entity: utri; with a semi-colon", + "output": [ + [ + "Character", + "\u25b5" + ] + ] + }, + { + "input": "&utrif", + "description": "Bad named entity: utrif without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&utrif" + ] + ] + }, + { + "input": "▴", + "description": "Named entity: utrif; with a semi-colon", + "output": [ + [ + "Character", + "\u25b4" + ] + ] + }, + { + "input": "&uuarr", + "description": "Bad named entity: uuarr without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&uuarr" + ] + ] + }, + { + "input": "⇈", + "description": "Named entity: uuarr; with a semi-colon", + "output": [ + [ + "Character", + "\u21c8" + ] + ] + }, + { + "input": "ü", + "description": "Named entity: uuml without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "\u00fc" + ] + ] + }, + { + "input": "ü", + "description": "Named entity: uuml; with a semi-colon", + "output": [ + [ + "Character", + "\u00fc" + ] + ] + }, + { + "input": "&uwangle", + "description": "Bad named entity: uwangle without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&uwangle" + ] + ] + }, + { + "input": "⦧", + "description": "Named entity: uwangle; with a semi-colon", + "output": [ + [ + "Character", + "\u29a7" + ] + ] + }, + { + "input": "&vArr", + "description": "Bad named entity: vArr without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&vArr" + ] + ] + }, + { + "input": "⇕", + "description": "Named entity: vArr; with a semi-colon", + "output": [ + [ + "Character", + "\u21d5" + ] + ] + }, + { + "input": "&vBar", + "description": "Bad named entity: vBar without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&vBar" + ] + ] + }, + { + "input": "⫨", + "description": "Named entity: vBar; with a semi-colon", + "output": [ + [ + "Character", + "\u2ae8" + ] + ] + }, + { + "input": "&vBarv", + "description": "Bad named entity: vBarv without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&vBarv" + ] + ] + }, + { + "input": "⫩", + "description": "Named entity: vBarv; with a semi-colon", + "output": [ + [ + "Character", + "\u2ae9" + ] + ] + }, + { + "input": "&vDash", + "description": "Bad named entity: vDash without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&vDash" + ] + ] + }, + { + "input": "⊨", + "description": "Named entity: vDash; with a semi-colon", + "output": [ + [ + "Character", + "\u22a8" + ] + ] + }, + { + "input": "&vangrt", + "description": "Bad named entity: vangrt without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&vangrt" + ] + ] + }, + { + "input": "⦜", + "description": "Named entity: vangrt; with a semi-colon", + "output": [ + [ + "Character", + "\u299c" + ] + ] + }, + { + "input": "&varepsilon", + "description": "Bad named entity: varepsilon without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&varepsilon" + ] + ] + }, + { + "input": "ϵ", + "description": "Named entity: varepsilon; with a semi-colon", + "output": [ + [ + "Character", + "\u03f5" + ] + ] + }, + { + "input": "&varkappa", + "description": "Bad named entity: varkappa without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&varkappa" + ] + ] + }, + { + "input": "ϰ", + "description": "Named entity: varkappa; with a semi-colon", + "output": [ + [ + "Character", + "\u03f0" + ] + ] + }, + { + "input": "&varnothing", + "description": "Bad named entity: varnothing without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&varnothing" + ] + ] + }, + { + "input": "∅", + "description": "Named entity: varnothing; with a semi-colon", + "output": [ + [ + "Character", + "\u2205" + ] + ] + }, + { + "input": "&varphi", + "description": "Bad named entity: varphi without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&varphi" + ] + ] + }, + { + "input": "ϕ", + "description": "Named entity: varphi; with a semi-colon", + "output": [ + [ + "Character", + "\u03d5" + ] + ] + }, + { + "input": "&varpi", + "description": "Bad named entity: varpi without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&varpi" + ] + ] + }, + { + "input": "ϖ", + "description": "Named entity: varpi; with a semi-colon", + "output": [ + [ + "Character", + "\u03d6" + ] + ] + }, + { + "input": "&varpropto", + "description": "Bad named entity: varpropto without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&varpropto" + ] + ] + }, + { + "input": "∝", + "description": "Named entity: varpropto; with a semi-colon", + "output": [ + [ + "Character", + "\u221d" + ] + ] + }, + { + "input": "&varr", + "description": "Bad named entity: varr without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&varr" + ] + ] + }, + { + "input": "↕", + "description": "Named entity: varr; with a semi-colon", + "output": [ + [ + "Character", + "\u2195" + ] + ] + }, + { + "input": "&varrho", + "description": "Bad named entity: varrho without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&varrho" + ] + ] + }, + { + "input": "ϱ", + "description": "Named entity: varrho; with a semi-colon", + "output": [ + [ + "Character", + "\u03f1" + ] + ] + }, + { + "input": "&varsigma", + "description": "Bad named entity: varsigma without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&varsigma" + ] + ] + }, + { + "input": "ς", + "description": "Named entity: varsigma; with a semi-colon", + "output": [ + [ + "Character", + "\u03c2" + ] + ] + }, + { + "input": "&varsubsetneq", + "description": "Bad named entity: varsubsetneq without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&varsubsetneq" + ] + ] + }, + { + "input": "⊊︀", + "description": "Named entity: varsubsetneq; with a semi-colon", + "output": [ + [ + "Character", + "\u228a\ufe00" + ] + ] + }, + { + "input": "&varsubsetneqq", + "description": "Bad named entity: varsubsetneqq without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&varsubsetneqq" + ] + ] + }, + { + "input": "⫋︀", + "description": "Named entity: varsubsetneqq; with a semi-colon", + "output": [ + [ + "Character", + "\u2acb\ufe00" + ] + ] + }, + { + "input": "&varsupsetneq", + "description": "Bad named entity: varsupsetneq without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&varsupsetneq" + ] + ] + }, + { + "input": "⊋︀", + "description": "Named entity: varsupsetneq; with a semi-colon", + "output": [ + [ + "Character", + "\u228b\ufe00" + ] + ] + }, + { + "input": "&varsupsetneqq", + "description": "Bad named entity: varsupsetneqq without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&varsupsetneqq" + ] + ] + }, + { + "input": "⫌︀", + "description": "Named entity: varsupsetneqq; with a semi-colon", + "output": [ + [ + "Character", + "\u2acc\ufe00" + ] + ] + }, + { + "input": "&vartheta", + "description": "Bad named entity: vartheta without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&vartheta" + ] + ] + }, + { + "input": "ϑ", + "description": "Named entity: vartheta; with a semi-colon", + "output": [ + [ + "Character", + "\u03d1" + ] + ] + }, + { + "input": "&vartriangleleft", + "description": "Bad named entity: vartriangleleft without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&vartriangleleft" + ] + ] + }, + { + "input": "⊲", + "description": "Named entity: vartriangleleft; with a semi-colon", + "output": [ + [ + "Character", + "\u22b2" + ] + ] + }, + { + "input": "&vartriangleright", + "description": "Bad named entity: vartriangleright without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&vartriangleright" + ] + ] + }, + { + "input": "⊳", + "description": "Named entity: vartriangleright; with a semi-colon", + "output": [ + [ + "Character", + "\u22b3" + ] + ] + }, + { + "input": "&vcy", + "description": "Bad named entity: vcy without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&vcy" + ] + ] + }, + { + "input": "в", + "description": "Named entity: vcy; with a semi-colon", + "output": [ + [ + "Character", + "\u0432" + ] + ] + }, + { + "input": "&vdash", + "description": "Bad named entity: vdash without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&vdash" + ] + ] + }, + { + "input": "⊢", + "description": "Named entity: vdash; with a semi-colon", + "output": [ + [ + "Character", + "\u22a2" + ] + ] + }, + { + "input": "&vee", + "description": "Bad named entity: vee without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&vee" + ] + ] + }, + { + "input": "∨", + "description": "Named entity: vee; with a semi-colon", + "output": [ + [ + "Character", + "\u2228" + ] + ] + }, + { + "input": "&veebar", + "description": "Bad named entity: veebar without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&veebar" + ] + ] + }, + { + "input": "⊻", + "description": "Named entity: veebar; with a semi-colon", + "output": [ + [ + "Character", + "\u22bb" + ] + ] + }, + { + "input": "&veeeq", + "description": "Bad named entity: veeeq without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&veeeq" + ] + ] + }, + { + "input": "≚", + "description": "Named entity: veeeq; with a semi-colon", + "output": [ + [ + "Character", + "\u225a" + ] + ] + }, + { + "input": "&vellip", + "description": "Bad named entity: vellip without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&vellip" + ] + ] + }, + { + "input": "⋮", + "description": "Named entity: vellip; with a semi-colon", + "output": [ + [ + "Character", + "\u22ee" + ] + ] + }, + { + "input": "&verbar", + "description": "Bad named entity: verbar without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&verbar" + ] + ] + }, + { + "input": "|", + "description": "Named entity: verbar; with a semi-colon", + "output": [ + [ + "Character", + "|" + ] + ] + }, + { + "input": "&vert", + "description": "Bad named entity: vert without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&vert" + ] + ] + }, + { + "input": "|", + "description": "Named entity: vert; with a semi-colon", + "output": [ + [ + "Character", + "|" + ] + ] + }, + { + "input": "&vfr", + "description": "Bad named entity: vfr without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&vfr" + ] + ] + }, + { + "input": "𝔳", + "description": "Named entity: vfr; with a semi-colon", + "output": [ + [ + "Character", + "\ud835\udd33" + ] + ] + }, + { + "input": "&vltri", + "description": "Bad named entity: vltri without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&vltri" + ] + ] + }, + { + "input": "⊲", + "description": "Named entity: vltri; with a semi-colon", + "output": [ + [ + "Character", + "\u22b2" + ] + ] + }, + { + "input": "&vnsub", + "description": "Bad named entity: vnsub without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&vnsub" + ] + ] + }, + { + "input": "⊂⃒", + "description": "Named entity: vnsub; with a semi-colon", + "output": [ + [ + "Character", + "\u2282\u20d2" + ] + ] + }, + { + "input": "&vnsup", + "description": "Bad named entity: vnsup without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&vnsup" + ] + ] + }, + { + "input": "⊃⃒", + "description": "Named entity: vnsup; with a semi-colon", + "output": [ + [ + "Character", + "\u2283\u20d2" + ] + ] + }, + { + "input": "&vopf", + "description": "Bad named entity: vopf without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&vopf" + ] + ] + }, + { + "input": "𝕧", + "description": "Named entity: vopf; with a semi-colon", + "output": [ + [ + "Character", + "\ud835\udd67" + ] + ] + }, + { + "input": "&vprop", + "description": "Bad named entity: vprop without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&vprop" + ] + ] + }, + { + "input": "∝", + "description": "Named entity: vprop; with a semi-colon", + "output": [ + [ + "Character", + "\u221d" + ] + ] + }, + { + "input": "&vrtri", + "description": "Bad named entity: vrtri without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&vrtri" + ] + ] + }, + { + "input": "⊳", + "description": "Named entity: vrtri; with a semi-colon", + "output": [ + [ + "Character", + "\u22b3" + ] + ] + }, + { + "input": "&vscr", + "description": "Bad named entity: vscr without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&vscr" + ] + ] + }, + { + "input": "𝓋", + "description": "Named entity: vscr; with a semi-colon", + "output": [ + [ + "Character", + "\ud835\udccb" + ] + ] + }, + { + "input": "&vsubnE", + "description": "Bad named entity: vsubnE without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&vsubnE" + ] + ] + }, + { + "input": "⫋︀", + "description": "Named entity: vsubnE; with a semi-colon", + "output": [ + [ + "Character", + "\u2acb\ufe00" + ] + ] + }, + { + "input": "&vsubne", + "description": "Bad named entity: vsubne without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&vsubne" + ] + ] + }, + { + "input": "⊊︀", + "description": "Named entity: vsubne; with a semi-colon", + "output": [ + [ + "Character", + "\u228a\ufe00" + ] + ] + }, + { + "input": "&vsupnE", + "description": "Bad named entity: vsupnE without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&vsupnE" + ] + ] + }, + { + "input": "⫌︀", + "description": "Named entity: vsupnE; with a semi-colon", + "output": [ + [ + "Character", + "\u2acc\ufe00" + ] + ] + }, + { + "input": "&vsupne", + "description": "Bad named entity: vsupne without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&vsupne" + ] + ] + }, + { + "input": "⊋︀", + "description": "Named entity: vsupne; with a semi-colon", + "output": [ + [ + "Character", + "\u228b\ufe00" + ] + ] + }, + { + "input": "&vzigzag", + "description": "Bad named entity: vzigzag without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&vzigzag" + ] + ] + }, + { + "input": "⦚", + "description": "Named entity: vzigzag; with a semi-colon", + "output": [ + [ + "Character", + "\u299a" + ] + ] + }, + { + "input": "&wcirc", + "description": "Bad named entity: wcirc without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&wcirc" + ] + ] + }, + { + "input": "ŵ", + "description": "Named entity: wcirc; with a semi-colon", + "output": [ + [ + "Character", + "\u0175" + ] + ] + }, + { + "input": "&wedbar", + "description": "Bad named entity: wedbar without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&wedbar" + ] + ] + }, + { + "input": "⩟", + "description": "Named entity: wedbar; with a semi-colon", + "output": [ + [ + "Character", + "\u2a5f" + ] + ] + }, + { + "input": "&wedge", + "description": "Bad named entity: wedge without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&wedge" + ] + ] + }, + { + "input": "∧", + "description": "Named entity: wedge; with a semi-colon", + "output": [ + [ + "Character", + "\u2227" + ] + ] + }, + { + "input": "&wedgeq", + "description": "Bad named entity: wedgeq without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&wedgeq" + ] + ] + }, + { + "input": "≙", + "description": "Named entity: wedgeq; with a semi-colon", + "output": [ + [ + "Character", + "\u2259" + ] + ] + }, + { + "input": "&weierp", + "description": "Bad named entity: weierp without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&weierp" + ] + ] + }, + { + "input": "℘", + "description": "Named entity: weierp; with a semi-colon", + "output": [ + [ + "Character", + "\u2118" + ] + ] + }, + { + "input": "&wfr", + "description": "Bad named entity: wfr without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&wfr" + ] + ] + }, + { + "input": "𝔴", + "description": "Named entity: wfr; with a semi-colon", + "output": [ + [ + "Character", + "\ud835\udd34" + ] + ] + }, + { + "input": "&wopf", + "description": "Bad named entity: wopf without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&wopf" + ] + ] + }, + { + "input": "𝕨", + "description": "Named entity: wopf; with a semi-colon", + "output": [ + [ + "Character", + "\ud835\udd68" + ] + ] + }, + { + "input": "&wp", + "description": "Bad named entity: wp without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&wp" + ] + ] + }, + { + "input": "℘", + "description": "Named entity: wp; with a semi-colon", + "output": [ + [ + "Character", + "\u2118" + ] + ] + }, + { + "input": "&wr", + "description": "Bad named entity: wr without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&wr" + ] + ] + }, + { + "input": "≀", + "description": "Named entity: wr; with a semi-colon", + "output": [ + [ + "Character", + "\u2240" + ] + ] + }, + { + "input": "&wreath", + "description": "Bad named entity: wreath without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&wreath" + ] + ] + }, + { + "input": "≀", + "description": "Named entity: wreath; with a semi-colon", + "output": [ + [ + "Character", + "\u2240" + ] + ] + }, + { + "input": "&wscr", + "description": "Bad named entity: wscr without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&wscr" + ] + ] + }, + { + "input": "𝓌", + "description": "Named entity: wscr; with a semi-colon", + "output": [ + [ + "Character", + "\ud835\udccc" + ] + ] + }, + { + "input": "&xcap", + "description": "Bad named entity: xcap without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&xcap" + ] + ] + }, + { + "input": "⋂", + "description": "Named entity: xcap; with a semi-colon", + "output": [ + [ + "Character", + "\u22c2" + ] + ] + }, + { + "input": "&xcirc", + "description": "Bad named entity: xcirc without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&xcirc" + ] + ] + }, + { + "input": "◯", + "description": "Named entity: xcirc; with a semi-colon", + "output": [ + [ + "Character", + "\u25ef" + ] + ] + }, + { + "input": "&xcup", + "description": "Bad named entity: xcup without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&xcup" + ] + ] + }, + { + "input": "⋃", + "description": "Named entity: xcup; with a semi-colon", + "output": [ + [ + "Character", + "\u22c3" + ] + ] + }, + { + "input": "&xdtri", + "description": "Bad named entity: xdtri without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&xdtri" + ] + ] + }, + { + "input": "▽", + "description": "Named entity: xdtri; with a semi-colon", + "output": [ + [ + "Character", + "\u25bd" + ] + ] + }, + { + "input": "&xfr", + "description": "Bad named entity: xfr without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&xfr" + ] + ] + }, + { + "input": "𝔵", + "description": "Named entity: xfr; with a semi-colon", + "output": [ + [ + "Character", + "\ud835\udd35" + ] + ] + }, + { + "input": "&xhArr", + "description": "Bad named entity: xhArr without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&xhArr" + ] + ] + }, + { + "input": "⟺", + "description": "Named entity: xhArr; with a semi-colon", + "output": [ + [ + "Character", + "\u27fa" + ] + ] + }, + { + "input": "&xharr", + "description": "Bad named entity: xharr without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&xharr" + ] + ] + }, + { + "input": "⟷", + "description": "Named entity: xharr; with a semi-colon", + "output": [ + [ + "Character", + "\u27f7" + ] + ] + }, + { + "input": "&xi", + "description": "Bad named entity: xi without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&xi" + ] + ] + }, + { + "input": "ξ", + "description": "Named entity: xi; with a semi-colon", + "output": [ + [ + "Character", + "\u03be" + ] + ] + }, + { + "input": "&xlArr", + "description": "Bad named entity: xlArr without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&xlArr" + ] + ] + }, + { + "input": "⟸", + "description": "Named entity: xlArr; with a semi-colon", + "output": [ + [ + "Character", + "\u27f8" + ] + ] + }, + { + "input": "&xlarr", + "description": "Bad named entity: xlarr without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&xlarr" + ] + ] + }, + { + "input": "⟵", + "description": "Named entity: xlarr; with a semi-colon", + "output": [ + [ + "Character", + "\u27f5" + ] + ] + }, + { + "input": "&xmap", + "description": "Bad named entity: xmap without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&xmap" + ] + ] + }, + { + "input": "⟼", + "description": "Named entity: xmap; with a semi-colon", + "output": [ + [ + "Character", + "\u27fc" + ] + ] + }, + { + "input": "&xnis", + "description": "Bad named entity: xnis without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&xnis" + ] + ] + }, + { + "input": "⋻", + "description": "Named entity: xnis; with a semi-colon", + "output": [ + [ + "Character", + "\u22fb" + ] + ] + }, + { + "input": "&xodot", + "description": "Bad named entity: xodot without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&xodot" + ] + ] + }, + { + "input": "⨀", + "description": "Named entity: xodot; with a semi-colon", + "output": [ + [ + "Character", + "\u2a00" + ] + ] + }, + { + "input": "&xopf", + "description": "Bad named entity: xopf without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&xopf" + ] + ] + }, + { + "input": "𝕩", + "description": "Named entity: xopf; with a semi-colon", + "output": [ + [ + "Character", + "\ud835\udd69" + ] + ] + }, + { + "input": "&xoplus", + "description": "Bad named entity: xoplus without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&xoplus" + ] + ] + }, + { + "input": "⨁", + "description": "Named entity: xoplus; with a semi-colon", + "output": [ + [ + "Character", + "\u2a01" + ] + ] + }, + { + "input": "&xotime", + "description": "Bad named entity: xotime without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&xotime" + ] + ] + }, + { + "input": "⨂", + "description": "Named entity: xotime; with a semi-colon", + "output": [ + [ + "Character", + "\u2a02" + ] + ] + }, + { + "input": "&xrArr", + "description": "Bad named entity: xrArr without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&xrArr" + ] + ] + }, + { + "input": "⟹", + "description": "Named entity: xrArr; with a semi-colon", + "output": [ + [ + "Character", + "\u27f9" + ] + ] + }, + { + "input": "&xrarr", + "description": "Bad named entity: xrarr without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&xrarr" + ] + ] + }, + { + "input": "⟶", + "description": "Named entity: xrarr; with a semi-colon", + "output": [ + [ + "Character", + "\u27f6" + ] + ] + }, + { + "input": "&xscr", + "description": "Bad named entity: xscr without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&xscr" + ] + ] + }, + { + "input": "𝓍", + "description": "Named entity: xscr; with a semi-colon", + "output": [ + [ + "Character", + "\ud835\udccd" + ] + ] + }, + { + "input": "&xsqcup", + "description": "Bad named entity: xsqcup without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&xsqcup" + ] + ] + }, + { + "input": "⨆", + "description": "Named entity: xsqcup; with a semi-colon", + "output": [ + [ + "Character", + "\u2a06" + ] + ] + }, + { + "input": "&xuplus", + "description": "Bad named entity: xuplus without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&xuplus" + ] + ] + }, + { + "input": "⨄", + "description": "Named entity: xuplus; with a semi-colon", + "output": [ + [ + "Character", + "\u2a04" + ] + ] + }, + { + "input": "&xutri", + "description": "Bad named entity: xutri without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&xutri" + ] + ] + }, + { + "input": "△", + "description": "Named entity: xutri; with a semi-colon", + "output": [ + [ + "Character", + "\u25b3" + ] + ] + }, + { + "input": "&xvee", + "description": "Bad named entity: xvee without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&xvee" + ] + ] + }, + { + "input": "⋁", + "description": "Named entity: xvee; with a semi-colon", + "output": [ + [ + "Character", + "\u22c1" + ] + ] + }, + { + "input": "&xwedge", + "description": "Bad named entity: xwedge without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&xwedge" + ] + ] + }, + { + "input": "⋀", + "description": "Named entity: xwedge; with a semi-colon", + "output": [ + [ + "Character", + "\u22c0" + ] + ] + }, + { + "input": "ý", + "description": "Named entity: yacute without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "\u00fd" + ] + ] + }, + { + "input": "ý", + "description": "Named entity: yacute; with a semi-colon", + "output": [ + [ + "Character", + "\u00fd" + ] + ] + }, + { + "input": "&yacy", + "description": "Bad named entity: yacy without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&yacy" + ] + ] + }, + { + "input": "я", + "description": "Named entity: yacy; with a semi-colon", + "output": [ + [ + "Character", + "\u044f" + ] + ] + }, + { + "input": "&ycirc", + "description": "Bad named entity: ycirc without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&ycirc" + ] + ] + }, + { + "input": "ŷ", + "description": "Named entity: ycirc; with a semi-colon", + "output": [ + [ + "Character", + "\u0177" + ] + ] + }, + { + "input": "&ycy", + "description": "Bad named entity: ycy without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&ycy" + ] + ] + }, + { + "input": "ы", + "description": "Named entity: ycy; with a semi-colon", + "output": [ + [ + "Character", + "\u044b" + ] + ] + }, + { + "input": "¥", + "description": "Named entity: yen without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "\u00a5" + ] + ] + }, + { + "input": "¥", + "description": "Named entity: yen; with a semi-colon", + "output": [ + [ + "Character", + "\u00a5" + ] + ] + }, + { + "input": "&yfr", + "description": "Bad named entity: yfr without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&yfr" + ] + ] + }, + { + "input": "𝔶", + "description": "Named entity: yfr; with a semi-colon", + "output": [ + [ + "Character", + "\ud835\udd36" + ] + ] + }, + { + "input": "&yicy", + "description": "Bad named entity: yicy without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&yicy" + ] + ] + }, + { + "input": "ї", + "description": "Named entity: yicy; with a semi-colon", + "output": [ + [ + "Character", + "\u0457" + ] + ] + }, + { + "input": "&yopf", + "description": "Bad named entity: yopf without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&yopf" + ] + ] + }, + { + "input": "𝕪", + "description": "Named entity: yopf; with a semi-colon", + "output": [ + [ + "Character", + "\ud835\udd6a" + ] + ] + }, + { + "input": "&yscr", + "description": "Bad named entity: yscr without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&yscr" + ] + ] + }, + { + "input": "𝓎", + "description": "Named entity: yscr; with a semi-colon", + "output": [ + [ + "Character", + "\ud835\udcce" + ] + ] + }, + { + "input": "&yucy", + "description": "Bad named entity: yucy without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&yucy" + ] + ] + }, + { + "input": "ю", + "description": "Named entity: yucy; with a semi-colon", + "output": [ + [ + "Character", + "\u044e" + ] + ] + }, + { + "input": "ÿ", + "description": "Named entity: yuml without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "\u00ff" + ] + ] + }, + { + "input": "ÿ", + "description": "Named entity: yuml; with a semi-colon", + "output": [ + [ + "Character", + "\u00ff" + ] + ] + }, + { + "input": "&zacute", + "description": "Bad named entity: zacute without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&zacute" + ] + ] + }, + { + "input": "ź", + "description": "Named entity: zacute; with a semi-colon", + "output": [ + [ + "Character", + "\u017a" + ] + ] + }, + { + "input": "&zcaron", + "description": "Bad named entity: zcaron without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&zcaron" + ] + ] + }, + { + "input": "ž", + "description": "Named entity: zcaron; with a semi-colon", + "output": [ + [ + "Character", + "\u017e" + ] + ] + }, + { + "input": "&zcy", + "description": "Bad named entity: zcy without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&zcy" + ] + ] + }, + { + "input": "з", + "description": "Named entity: zcy; with a semi-colon", + "output": [ + [ + "Character", + "\u0437" + ] + ] + }, + { + "input": "&zdot", + "description": "Bad named entity: zdot without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&zdot" + ] + ] + }, + { + "input": "ż", + "description": "Named entity: zdot; with a semi-colon", + "output": [ + [ + "Character", + "\u017c" + ] + ] + }, + { + "input": "&zeetrf", + "description": "Bad named entity: zeetrf without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&zeetrf" + ] + ] + }, + { + "input": "ℨ", + "description": "Named entity: zeetrf; with a semi-colon", + "output": [ + [ + "Character", + "\u2128" + ] + ] + }, + { + "input": "&zeta", + "description": "Bad named entity: zeta without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&zeta" + ] + ] + }, + { + "input": "ζ", + "description": "Named entity: zeta; with a semi-colon", + "output": [ + [ + "Character", + "\u03b6" + ] + ] + }, + { + "input": "&zfr", + "description": "Bad named entity: zfr without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&zfr" + ] + ] + }, + { + "input": "𝔷", + "description": "Named entity: zfr; with a semi-colon", + "output": [ + [ + "Character", + "\ud835\udd37" + ] + ] + }, + { + "input": "&zhcy", + "description": "Bad named entity: zhcy without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&zhcy" + ] + ] + }, + { + "input": "ж", + "description": "Named entity: zhcy; with a semi-colon", + "output": [ + [ + "Character", + "\u0436" + ] + ] + }, + { + "input": "&zigrarr", + "description": "Bad named entity: zigrarr without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&zigrarr" + ] + ] + }, + { + "input": "⇝", + "description": "Named entity: zigrarr; with a semi-colon", + "output": [ + [ + "Character", + "\u21dd" + ] + ] + }, + { + "input": "&zopf", + "description": "Bad named entity: zopf without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&zopf" + ] + ] + }, + { + "input": "𝕫", + "description": "Named entity: zopf; with a semi-colon", + "output": [ + [ + "Character", + "\ud835\udd6b" + ] + ] + }, + { + "input": "&zscr", + "description": "Bad named entity: zscr without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&zscr" + ] + ] + }, + { + "input": "𝓏", + "description": "Named entity: zscr; with a semi-colon", + "output": [ + [ + "Character", + "\ud835\udccf" + ] + ] + }, + { + "input": "&zwj", + "description": "Bad named entity: zwj without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&zwj" + ] + ] + }, + { + "input": "‍", + "description": "Named entity: zwj; with a semi-colon", + "output": [ + [ + "Character", + "\u200d" + ] + ] + }, + { + "input": "&zwnj", + "description": "Bad named entity: zwnj without a semi-colon", + "output": [ + "ParseError", + [ + "Character", + "&zwnj" + ] + ] + }, + { + "input": "‌", + "description": "Named entity: zwnj; with a semi-colon", + "output": [ + [ + "Character", + "\u200c" + ] + ] + } + ] +} \ No newline at end of file diff --git a/tests/data/tokenizer/numericEntities.test b/tests/data/tokenizer/numericEntities.test new file mode 100644 index 0000000..36c8228 --- /dev/null +++ b/tests/data/tokenizer/numericEntities.test @@ -0,0 +1,1313 @@ +{"tests": [ + +{"description": "Invalid numeric entity character U+0000", +"input": "�", +"output": ["ParseError", ["Character", "\uFFFD"]]}, + +{"description": "Invalid numeric entity character U+0001", +"input": "", +"output": ["ParseError", ["Character", "\u0001"]]}, + +{"description": "Invalid numeric entity character U+0002", +"input": "", +"output": ["ParseError", ["Character", "\u0002"]]}, + +{"description": "Invalid numeric entity character U+0003", +"input": "", +"output": ["ParseError", ["Character", "\u0003"]]}, + +{"description": "Invalid numeric entity character U+0004", +"input": "", +"output": ["ParseError", ["Character", "\u0004"]]}, + +{"description": "Invalid numeric entity character U+0005", +"input": "", +"output": ["ParseError", ["Character", "\u0005"]]}, + +{"description": "Invalid numeric entity character U+0006", +"input": "", +"output": ["ParseError", ["Character", "\u0006"]]}, + +{"description": "Invalid numeric entity character U+0007", +"input": "", +"output": ["ParseError", ["Character", "\u0007"]]}, + +{"description": "Invalid numeric entity character U+0008", +"input": "", +"output": ["ParseError", ["Character", "\u0008"]]}, + +{"description": "Invalid numeric entity character U+000B", +"input": " ", +"output": ["ParseError", ["Character", "\u000b"]]}, + +{"description": "Invalid numeric entity character U+000E", +"input": "", +"output": ["ParseError", ["Character", "\u000e"]]}, + +{"description": "Invalid numeric entity character U+000F", +"input": "", +"output": ["ParseError", ["Character", "\u000f"]]}, + +{"description": "Invalid numeric entity character U+0010", +"input": "", +"output": ["ParseError", ["Character", "\u0010"]]}, + +{"description": "Invalid numeric entity character U+0011", +"input": "", +"output": ["ParseError", ["Character", "\u0011"]]}, + +{"description": "Invalid numeric entity character U+0012", +"input": "", +"output": ["ParseError", ["Character", "\u0012"]]}, + +{"description": "Invalid numeric entity character U+0013", +"input": "", +"output": ["ParseError", ["Character", "\u0013"]]}, + +{"description": "Invalid numeric entity character U+0014", +"input": "", +"output": ["ParseError", ["Character", "\u0014"]]}, + +{"description": "Invalid numeric entity character U+0015", +"input": "", +"output": ["ParseError", ["Character", "\u0015"]]}, + +{"description": "Invalid numeric entity character U+0016", +"input": "", +"output": ["ParseError", ["Character", "\u0016"]]}, + +{"description": "Invalid numeric entity character U+0017", +"input": "", +"output": ["ParseError", ["Character", "\u0017"]]}, + +{"description": "Invalid numeric entity character U+0018", +"input": "", +"output": ["ParseError", ["Character", "\u0018"]]}, + +{"description": "Invalid numeric entity character U+0019", +"input": "", +"output": ["ParseError", ["Character", "\u0019"]]}, + +{"description": "Invalid numeric entity character U+001A", +"input": "", +"output": ["ParseError", ["Character", "\u001a"]]}, + +{"description": "Invalid numeric entity character U+001B", +"input": "", +"output": ["ParseError", ["Character", "\u001b"]]}, + +{"description": "Invalid numeric entity character U+001C", +"input": "", +"output": ["ParseError", ["Character", "\u001c"]]}, + +{"description": "Invalid numeric entity character U+001D", +"input": "", +"output": ["ParseError", ["Character", "\u001d"]]}, + +{"description": "Invalid numeric entity character U+001E", +"input": "", +"output": ["ParseError", ["Character", "\u001e"]]}, + +{"description": "Invalid numeric entity character U+001F", +"input": "", +"output": ["ParseError", ["Character", "\u001f"]]}, + +{"description": "Invalid numeric entity character U+007F", +"input": "", +"output": ["ParseError", ["Character", "\u007f"]]}, + +{"description": "Invalid numeric entity character U+D800", +"input": "�", +"output": ["ParseError", ["Character", "\uFFFD"]]}, + +{"description": "Invalid numeric entity character U+DFFF", +"input": "�", +"output": ["ParseError", ["Character", "\uFFFD"]]}, + +{"description": "Invalid numeric entity character U+FDD0", +"input": "﷐", +"output": ["ParseError", ["Character", "\ufdd0"]]}, + +{"description": "Invalid numeric entity character U+FDD1", +"input": "﷑", +"output": ["ParseError", ["Character", "\ufdd1"]]}, + +{"description": "Invalid numeric entity character U+FDD2", +"input": "﷒", +"output": ["ParseError", ["Character", "\ufdd2"]]}, + +{"description": "Invalid numeric entity character U+FDD3", +"input": "﷓", +"output": ["ParseError", ["Character", "\ufdd3"]]}, + +{"description": "Invalid numeric entity character U+FDD4", +"input": "﷔", +"output": ["ParseError", ["Character", "\ufdd4"]]}, + +{"description": "Invalid numeric entity character U+FDD5", +"input": "﷕", +"output": ["ParseError", ["Character", "\ufdd5"]]}, + +{"description": "Invalid numeric entity character U+FDD6", +"input": "﷖", +"output": ["ParseError", ["Character", "\ufdd6"]]}, + +{"description": "Invalid numeric entity character U+FDD7", +"input": "﷗", +"output": ["ParseError", ["Character", "\ufdd7"]]}, + +{"description": "Invalid numeric entity character U+FDD8", +"input": "﷘", +"output": ["ParseError", ["Character", "\ufdd8"]]}, + +{"description": "Invalid numeric entity character U+FDD9", +"input": "﷙", +"output": ["ParseError", ["Character", "\ufdd9"]]}, + +{"description": "Invalid numeric entity character U+FDDA", +"input": "﷚", +"output": ["ParseError", ["Character", "\ufdda"]]}, + +{"description": "Invalid numeric entity character U+FDDB", +"input": "﷛", +"output": ["ParseError", ["Character", "\ufddb"]]}, + +{"description": "Invalid numeric entity character U+FDDC", +"input": "﷜", +"output": ["ParseError", ["Character", "\ufddc"]]}, + +{"description": "Invalid numeric entity character U+FDDD", +"input": "﷝", +"output": ["ParseError", ["Character", "\ufddd"]]}, + +{"description": "Invalid numeric entity character U+FDDE", +"input": "﷞", +"output": ["ParseError", ["Character", "\ufdde"]]}, + +{"description": "Invalid numeric entity character U+FDDF", +"input": "﷟", +"output": ["ParseError", ["Character", "\ufddf"]]}, + +{"description": "Invalid numeric entity character U+FDE0", +"input": "﷠", +"output": ["ParseError", ["Character", "\ufde0"]]}, + +{"description": "Invalid numeric entity character U+FDE1", +"input": "﷡", +"output": ["ParseError", ["Character", "\ufde1"]]}, + +{"description": "Invalid numeric entity character U+FDE2", +"input": "﷢", +"output": ["ParseError", ["Character", "\ufde2"]]}, + +{"description": "Invalid numeric entity character U+FDE3", +"input": "﷣", +"output": ["ParseError", ["Character", "\ufde3"]]}, + +{"description": "Invalid numeric entity character U+FDE4", +"input": "﷤", +"output": ["ParseError", ["Character", "\ufde4"]]}, + +{"description": "Invalid numeric entity character U+FDE5", +"input": "﷥", +"output": ["ParseError", ["Character", "\ufde5"]]}, + +{"description": "Invalid numeric entity character U+FDE6", +"input": "﷦", +"output": ["ParseError", ["Character", "\ufde6"]]}, + +{"description": "Invalid numeric entity character U+FDE7", +"input": "﷧", +"output": ["ParseError", ["Character", "\ufde7"]]}, + +{"description": "Invalid numeric entity character U+FDE8", +"input": "﷨", +"output": ["ParseError", ["Character", "\ufde8"]]}, + +{"description": "Invalid numeric entity character U+FDE9", +"input": "﷩", +"output": ["ParseError", ["Character", "\ufde9"]]}, + +{"description": "Invalid numeric entity character U+FDEA", +"input": "﷪", +"output": ["ParseError", ["Character", "\ufdea"]]}, + +{"description": "Invalid numeric entity character U+FDEB", +"input": "﷫", +"output": ["ParseError", ["Character", "\ufdeb"]]}, + +{"description": "Invalid numeric entity character U+FDEC", +"input": "﷬", +"output": ["ParseError", ["Character", "\ufdec"]]}, + +{"description": "Invalid numeric entity character U+FDED", +"input": "﷭", +"output": ["ParseError", ["Character", "\ufded"]]}, + +{"description": "Invalid numeric entity character U+FDEE", +"input": "﷮", +"output": ["ParseError", ["Character", "\ufdee"]]}, + +{"description": "Invalid numeric entity character U+FDEF", +"input": "﷯", +"output": ["ParseError", ["Character", "\ufdef"]]}, + +{"description": "Invalid numeric entity character U+FFFE", +"input": "￾", +"output": ["ParseError", ["Character", "\ufffe"]]}, + +{"description": "Invalid numeric entity character U+FFFF", +"input": "￿", +"output": ["ParseError", ["Character", "\uffff"]]}, + +{"description": "Invalid numeric entity character U+1FFFE", +"input": "🿾", +"output": ["ParseError", ["Character", "\uD83F\uDFFE"]]}, + +{"description": "Invalid numeric entity character U+1FFFF", +"input": "🿿", +"output": ["ParseError", ["Character", "\uD83F\uDFFF"]]}, + +{"description": "Invalid numeric entity character U+2FFFE", +"input": "𯿾", +"output": ["ParseError", ["Character", "\uD87F\uDFFE"]]}, + +{"description": "Invalid numeric entity character U+2FFFF", +"input": "𯿿", +"output": ["ParseError", ["Character", "\uD87F\uDFFF"]]}, + +{"description": "Invalid numeric entity character U+3FFFE", +"input": "𿿾", +"output": ["ParseError", ["Character", "\uD8BF\uDFFE"]]}, + +{"description": "Invalid numeric entity character U+3FFFF", +"input": "𿿿", +"output": ["ParseError", ["Character", "\uD8BF\uDFFF"]]}, + +{"description": "Invalid numeric entity character U+4FFFE", +"input": "񏿾", +"output": ["ParseError", ["Character", "\uD8FF\uDFFE"]]}, + +{"description": "Invalid numeric entity character U+4FFFF", +"input": "񏿿", +"output": ["ParseError", ["Character", "\uD8FF\uDFFF"]]}, + +{"description": "Invalid numeric entity character U+5FFFE", +"input": "񟿾", +"output": ["ParseError", ["Character", "\uD93F\uDFFE"]]}, + +{"description": "Invalid numeric entity character U+5FFFF", +"input": "񟿿", +"output": ["ParseError", ["Character", "\uD93F\uDFFF"]]}, + +{"description": "Invalid numeric entity character U+6FFFE", +"input": "񯿾", +"output": ["ParseError", ["Character", "\uD97F\uDFFE"]]}, + +{"description": "Invalid numeric entity character U+6FFFF", +"input": "񯿿", +"output": ["ParseError", ["Character", "\uD97F\uDFFF"]]}, + +{"description": "Invalid numeric entity character U+7FFFE", +"input": "񿿾", +"output": ["ParseError", ["Character", "\uD9BF\uDFFE"]]}, + +{"description": "Invalid numeric entity character U+7FFFF", +"input": "񿿿", +"output": ["ParseError", ["Character", "\uD9BF\uDFFF"]]}, + +{"description": "Invalid numeric entity character U+8FFFE", +"input": "򏿾", +"output": ["ParseError", ["Character", "\uD9FF\uDFFE"]]}, + +{"description": "Invalid numeric entity character U+8FFFF", +"input": "򏿿", +"output": ["ParseError", ["Character", "\uD9FF\uDFFF"]]}, + +{"description": "Invalid numeric entity character U+9FFFE", +"input": "򟿾", +"output": ["ParseError", ["Character", "\uDA3F\uDFFE"]]}, + +{"description": "Invalid numeric entity character U+9FFFF", +"input": "򟿿", +"output": ["ParseError", ["Character", "\uDA3F\uDFFF"]]}, + +{"description": "Invalid numeric entity character U+AFFFE", +"input": "򯿾", +"output": ["ParseError", ["Character", "\uDA7F\uDFFE"]]}, + +{"description": "Invalid numeric entity character U+AFFFF", +"input": "򯿿", +"output": ["ParseError", ["Character", "\uDA7F\uDFFF"]]}, + +{"description": "Invalid numeric entity character U+BFFFE", +"input": "򿿾", +"output": ["ParseError", ["Character", "\uDABF\uDFFE"]]}, + +{"description": "Invalid numeric entity character U+BFFFF", +"input": "򿿿", +"output": ["ParseError", ["Character", "\uDABF\uDFFF"]]}, + +{"description": "Invalid numeric entity character U+CFFFE", +"input": "󏿾", +"output": ["ParseError", ["Character", "\uDAFF\uDFFE"]]}, + +{"description": "Invalid numeric entity character U+CFFFF", +"input": "󏿿", +"output": ["ParseError", ["Character", "\uDAFF\uDFFF"]]}, + +{"description": "Invalid numeric entity character U+DFFFE", +"input": "󟿾", +"output": ["ParseError", ["Character", "\uDB3F\uDFFE"]]}, + +{"description": "Invalid numeric entity character U+DFFFF", +"input": "󟿿", +"output": ["ParseError", ["Character", "\uDB3F\uDFFF"]]}, + +{"description": "Invalid numeric entity character U+EFFFE", +"input": "󯿾", +"output": ["ParseError", ["Character", "\uDB7F\uDFFE"]]}, + +{"description": "Invalid numeric entity character U+EFFFF", +"input": "󯿿", +"output": ["ParseError", ["Character", "\uDB7F\uDFFF"]]}, + +{"description": "Invalid numeric entity character U+FFFFE", +"input": "󿿾", +"output": ["ParseError", ["Character", "\uDBBF\uDFFE"]]}, + +{"description": "Invalid numeric entity character U+FFFFF", +"input": "󿿿", +"output": ["ParseError", ["Character", "\uDBBF\uDFFF"]]}, + +{"description": "Invalid numeric entity character U+10FFFE", +"input": "􏿾", +"output": ["ParseError", ["Character", "\uDBFF\uDFFE"]]}, + +{"description": "Invalid numeric entity character U+10FFFF", +"input": "􏿿", +"output": ["ParseError", ["Character", "\uDBFF\uDFFF"]]}, + +{"description": "Valid numeric entity character U+0009", +"input": " ", +"output": [["Character", "\u0009"]]}, + +{"description": "Valid numeric entity character U+000A", +"input": " ", +"output": [["Character", "\u000A"]]}, + +{"description": "Valid numeric entity character U+0020", +"input": " ", +"output": [["Character", "\u0020"]]}, + +{"description": "Valid numeric entity character U+0021", +"input": "!", +"output": [["Character", "\u0021"]]}, + +{"description": "Valid numeric entity character U+0022", +"input": """, +"output": [["Character", "\u0022"]]}, + +{"description": "Valid numeric entity character U+0023", +"input": "#", +"output": [["Character", "\u0023"]]}, + +{"description": "Valid numeric entity character U+0024", +"input": "$", +"output": [["Character", "\u0024"]]}, + +{"description": "Valid numeric entity character U+0025", +"input": "%", +"output": [["Character", "\u0025"]]}, + +{"description": "Valid numeric entity character U+0026", +"input": "&", +"output": [["Character", "\u0026"]]}, + +{"description": "Valid numeric entity character U+0027", +"input": "'", +"output": [["Character", "\u0027"]]}, + +{"description": "Valid numeric entity character U+0028", +"input": "(", +"output": [["Character", "\u0028"]]}, + +{"description": "Valid numeric entity character U+0029", +"input": ")", +"output": [["Character", "\u0029"]]}, + +{"description": "Valid numeric entity character U+002A", +"input": "*", +"output": [["Character", "\u002A"]]}, + +{"description": "Valid numeric entity character U+002B", +"input": "+", +"output": [["Character", "\u002B"]]}, + +{"description": "Valid numeric entity character U+002C", +"input": ",", +"output": [["Character", "\u002C"]]}, + +{"description": "Valid numeric entity character U+002D", +"input": "-", +"output": [["Character", "\u002D"]]}, + +{"description": "Valid numeric entity character U+002E", +"input": ".", +"output": [["Character", "\u002E"]]}, + +{"description": "Valid numeric entity character U+002F", +"input": "/", +"output": [["Character", "\u002F"]]}, + +{"description": "Valid numeric entity character U+0030", +"input": "0", +"output": [["Character", "\u0030"]]}, + +{"description": "Valid numeric entity character U+0031", +"input": "1", +"output": [["Character", "\u0031"]]}, + +{"description": "Valid numeric entity character U+0032", +"input": "2", +"output": [["Character", "\u0032"]]}, + +{"description": "Valid numeric entity character U+0033", +"input": "3", +"output": [["Character", "\u0033"]]}, + +{"description": "Valid numeric entity character U+0034", +"input": "4", +"output": [["Character", "\u0034"]]}, + +{"description": "Valid numeric entity character U+0035", +"input": "5", +"output": [["Character", "\u0035"]]}, + +{"description": "Valid numeric entity character U+0036", +"input": "6", +"output": [["Character", "\u0036"]]}, + +{"description": "Valid numeric entity character U+0037", +"input": "7", +"output": [["Character", "\u0037"]]}, + +{"description": "Valid numeric entity character U+0038", +"input": "8", +"output": [["Character", "\u0038"]]}, + +{"description": "Valid numeric entity character U+0039", +"input": "9", +"output": [["Character", "\u0039"]]}, + +{"description": "Valid numeric entity character U+003A", +"input": ":", +"output": [["Character", "\u003A"]]}, + +{"description": "Valid numeric entity character U+003B", +"input": ";", +"output": [["Character", "\u003B"]]}, + +{"description": "Valid numeric entity character U+003C", +"input": "<", +"output": [["Character", "\u003C"]]}, + +{"description": "Valid numeric entity character U+003D", +"input": "=", +"output": [["Character", "\u003D"]]}, + +{"description": "Valid numeric entity character U+003E", +"input": ">", +"output": [["Character", "\u003E"]]}, + +{"description": "Valid numeric entity character U+003F", +"input": "?", +"output": [["Character", "\u003F"]]}, + +{"description": "Valid numeric entity character U+0040", +"input": "@", +"output": [["Character", "\u0040"]]}, + +{"description": "Valid numeric entity character U+0041", +"input": "A", +"output": [["Character", "\u0041"]]}, + +{"description": "Valid numeric entity character U+0042", +"input": "B", +"output": [["Character", "\u0042"]]}, + +{"description": "Valid numeric entity character U+0043", +"input": "C", +"output": [["Character", "\u0043"]]}, + +{"description": "Valid numeric entity character U+0044", +"input": "D", +"output": [["Character", "\u0044"]]}, + +{"description": "Valid numeric entity character U+0045", +"input": "E", +"output": [["Character", "\u0045"]]}, + +{"description": "Valid numeric entity character U+0046", +"input": "F", +"output": [["Character", "\u0046"]]}, + +{"description": "Valid numeric entity character U+0047", +"input": "G", +"output": [["Character", "\u0047"]]}, + +{"description": "Valid numeric entity character U+0048", +"input": "H", +"output": [["Character", "\u0048"]]}, + +{"description": "Valid numeric entity character U+0049", +"input": "I", +"output": [["Character", "\u0049"]]}, + +{"description": "Valid numeric entity character U+004A", +"input": "J", +"output": [["Character", "\u004A"]]}, + +{"description": "Valid numeric entity character U+004B", +"input": "K", +"output": [["Character", "\u004B"]]}, + +{"description": "Valid numeric entity character U+004C", +"input": "L", +"output": [["Character", "\u004C"]]}, + +{"description": "Valid numeric entity character U+004D", +"input": "M", +"output": [["Character", "\u004D"]]}, + +{"description": "Valid numeric entity character U+004E", +"input": "N", +"output": [["Character", "\u004E"]]}, + +{"description": "Valid numeric entity character U+004F", +"input": "O", +"output": [["Character", "\u004F"]]}, + +{"description": "Valid numeric entity character U+0050", +"input": "P", +"output": [["Character", "\u0050"]]}, + +{"description": "Valid numeric entity character U+0051", +"input": "Q", +"output": [["Character", "\u0051"]]}, + +{"description": "Valid numeric entity character U+0052", +"input": "R", +"output": [["Character", "\u0052"]]}, + +{"description": "Valid numeric entity character U+0053", +"input": "S", +"output": [["Character", "\u0053"]]}, + +{"description": "Valid numeric entity character U+0054", +"input": "T", +"output": [["Character", "\u0054"]]}, + +{"description": "Valid numeric entity character U+0055", +"input": "U", +"output": [["Character", "\u0055"]]}, + +{"description": "Valid numeric entity character U+0056", +"input": "V", +"output": [["Character", "\u0056"]]}, + +{"description": "Valid numeric entity character U+0057", +"input": "W", +"output": [["Character", "\u0057"]]}, + +{"description": "Valid numeric entity character U+0058", +"input": "X", +"output": [["Character", "\u0058"]]}, + +{"description": "Valid numeric entity character U+0059", +"input": "Y", +"output": [["Character", "\u0059"]]}, + +{"description": "Valid numeric entity character U+005A", +"input": "Z", +"output": [["Character", "\u005A"]]}, + +{"description": "Valid numeric entity character U+005B", +"input": "[", +"output": [["Character", "\u005B"]]}, + +{"description": "Valid numeric entity character U+005C", +"input": "\", +"output": [["Character", "\u005C"]]}, + +{"description": "Valid numeric entity character U+005D", +"input": "]", +"output": [["Character", "\u005D"]]}, + +{"description": "Valid numeric entity character U+005E", +"input": "^", +"output": [["Character", "\u005E"]]}, + +{"description": "Valid numeric entity character U+005F", +"input": "_", +"output": [["Character", "\u005F"]]}, + +{"description": "Valid numeric entity character U+0060", +"input": "`", +"output": [["Character", "\u0060"]]}, + +{"description": "Valid numeric entity character U+0061", +"input": "a", +"output": [["Character", "\u0061"]]}, + +{"description": "Valid numeric entity character U+0062", +"input": "b", +"output": [["Character", "\u0062"]]}, + +{"description": "Valid numeric entity character U+0063", +"input": "c", +"output": [["Character", "\u0063"]]}, + +{"description": "Valid numeric entity character U+0064", +"input": "d", +"output": [["Character", "\u0064"]]}, + +{"description": "Valid numeric entity character U+0065", +"input": "e", +"output": [["Character", "\u0065"]]}, + +{"description": "Valid numeric entity character U+0066", +"input": "f", +"output": [["Character", "\u0066"]]}, + +{"description": "Valid numeric entity character U+0067", +"input": "g", +"output": [["Character", "\u0067"]]}, + +{"description": "Valid numeric entity character U+0068", +"input": "h", +"output": [["Character", "\u0068"]]}, + +{"description": "Valid numeric entity character U+0069", +"input": "i", +"output": [["Character", "\u0069"]]}, + +{"description": "Valid numeric entity character U+006A", +"input": "j", +"output": [["Character", "\u006A"]]}, + +{"description": "Valid numeric entity character U+006B", +"input": "k", +"output": [["Character", "\u006B"]]}, + +{"description": "Valid numeric entity character U+006C", +"input": "l", +"output": [["Character", "\u006C"]]}, + +{"description": "Valid numeric entity character U+006D", +"input": "m", +"output": [["Character", "\u006D"]]}, + +{"description": "Valid numeric entity character U+006E", +"input": "n", +"output": [["Character", "\u006E"]]}, + +{"description": "Valid numeric entity character U+006F", +"input": "o", +"output": [["Character", "\u006F"]]}, + +{"description": "Valid numeric entity character U+0070", +"input": "p", +"output": [["Character", "\u0070"]]}, + +{"description": "Valid numeric entity character U+0071", +"input": "q", +"output": [["Character", "\u0071"]]}, + +{"description": "Valid numeric entity character U+0072", +"input": "r", +"output": [["Character", "\u0072"]]}, + +{"description": "Valid numeric entity character U+0073", +"input": "s", +"output": [["Character", "\u0073"]]}, + +{"description": "Valid numeric entity character U+0074", +"input": "t", +"output": [["Character", "\u0074"]]}, + +{"description": "Valid numeric entity character U+0075", +"input": "u", +"output": [["Character", "\u0075"]]}, + +{"description": "Valid numeric entity character U+0076", +"input": "v", +"output": [["Character", "\u0076"]]}, + +{"description": "Valid numeric entity character U+0077", +"input": "w", +"output": [["Character", "\u0077"]]}, + +{"description": "Valid numeric entity character U+0078", +"input": "x", +"output": [["Character", "\u0078"]]}, + +{"description": "Valid numeric entity character U+0079", +"input": "y", +"output": [["Character", "\u0079"]]}, + +{"description": "Valid numeric entity character U+007A", +"input": "z", +"output": [["Character", "\u007A"]]}, + +{"description": "Valid numeric entity character U+007B", +"input": "{", +"output": [["Character", "\u007B"]]}, + +{"description": "Valid numeric entity character U+007C", +"input": "|", +"output": [["Character", "\u007C"]]}, + +{"description": "Valid numeric entity character U+007D", +"input": "}", +"output": [["Character", "\u007D"]]}, + +{"description": "Valid numeric entity character U+007E", +"input": "~", +"output": [["Character", "\u007E"]]}, + +{"description": "Valid numeric entity character U+00A0", +"input": " ", +"output": [["Character", "\u00A0"]]}, + +{"description": "Valid numeric entity character U+00A1", +"input": "¡", +"output": [["Character", "\u00A1"]]}, + +{"description": "Valid numeric entity character U+00A2", +"input": "¢", +"output": [["Character", "\u00A2"]]}, + +{"description": "Valid numeric entity character U+00A3", +"input": "£", +"output": [["Character", "\u00A3"]]}, + +{"description": "Valid numeric entity character U+00A4", +"input": "¤", +"output": [["Character", "\u00A4"]]}, + +{"description": "Valid numeric entity character U+00A5", +"input": "¥", +"output": [["Character", "\u00A5"]]}, + +{"description": "Valid numeric entity character U+00A6", +"input": "¦", +"output": [["Character", "\u00A6"]]}, + +{"description": "Valid numeric entity character U+00A7", +"input": "§", +"output": [["Character", "\u00A7"]]}, + +{"description": "Valid numeric entity character U+00A8", +"input": "¨", +"output": [["Character", "\u00A8"]]}, + +{"description": "Valid numeric entity character U+00A9", +"input": "©", +"output": [["Character", "\u00A9"]]}, + +{"description": "Valid numeric entity character U+00AA", +"input": "ª", +"output": [["Character", "\u00AA"]]}, + +{"description": "Valid numeric entity character U+00AB", +"input": "«", +"output": [["Character", "\u00AB"]]}, + +{"description": "Valid numeric entity character U+00AC", +"input": "¬", +"output": [["Character", "\u00AC"]]}, + +{"description": "Valid numeric entity character U+00AD", +"input": "­", +"output": [["Character", "\u00AD"]]}, + +{"description": "Valid numeric entity character U+00AE", +"input": "®", +"output": [["Character", "\u00AE"]]}, + +{"description": "Valid numeric entity character U+00AF", +"input": "¯", +"output": [["Character", "\u00AF"]]}, + +{"description": "Valid numeric entity character U+00B0", +"input": "°", +"output": [["Character", "\u00B0"]]}, + +{"description": "Valid numeric entity character U+00B1", +"input": "±", +"output": [["Character", "\u00B1"]]}, + +{"description": "Valid numeric entity character U+00B2", +"input": "²", +"output": [["Character", "\u00B2"]]}, + +{"description": "Valid numeric entity character U+00B3", +"input": "³", +"output": [["Character", "\u00B3"]]}, + +{"description": "Valid numeric entity character U+00B4", +"input": "´", +"output": [["Character", "\u00B4"]]}, + +{"description": "Valid numeric entity character U+00B5", +"input": "µ", +"output": [["Character", "\u00B5"]]}, + +{"description": "Valid numeric entity character U+00B6", +"input": "¶", +"output": [["Character", "\u00B6"]]}, + +{"description": "Valid numeric entity character U+00B7", +"input": "·", +"output": [["Character", "\u00B7"]]}, + +{"description": "Valid numeric entity character U+00B8", +"input": "¸", +"output": [["Character", "\u00B8"]]}, + +{"description": "Valid numeric entity character U+00B9", +"input": "¹", +"output": [["Character", "\u00B9"]]}, + +{"description": "Valid numeric entity character U+00BA", +"input": "º", +"output": [["Character", "\u00BA"]]}, + +{"description": "Valid numeric entity character U+00BB", +"input": "»", +"output": [["Character", "\u00BB"]]}, + +{"description": "Valid numeric entity character U+00BC", +"input": "¼", +"output": [["Character", "\u00BC"]]}, + +{"description": "Valid numeric entity character U+00BD", +"input": "½", +"output": [["Character", "\u00BD"]]}, + +{"description": "Valid numeric entity character U+00BE", +"input": "¾", +"output": [["Character", "\u00BE"]]}, + +{"description": "Valid numeric entity character U+00BF", +"input": "¿", +"output": [["Character", "\u00BF"]]}, + +{"description": "Valid numeric entity character U+00C0", +"input": "À", +"output": [["Character", "\u00C0"]]}, + +{"description": "Valid numeric entity character U+00C1", +"input": "Á", +"output": [["Character", "\u00C1"]]}, + +{"description": "Valid numeric entity character U+00C2", +"input": "Â", +"output": [["Character", "\u00C2"]]}, + +{"description": "Valid numeric entity character U+00C3", +"input": "Ã", +"output": [["Character", "\u00C3"]]}, + +{"description": "Valid numeric entity character U+00C4", +"input": "Ä", +"output": [["Character", "\u00C4"]]}, + +{"description": "Valid numeric entity character U+00C5", +"input": "Å", +"output": [["Character", "\u00C5"]]}, + +{"description": "Valid numeric entity character U+00C6", +"input": "Æ", +"output": [["Character", "\u00C6"]]}, + +{"description": "Valid numeric entity character U+00C7", +"input": "Ç", +"output": [["Character", "\u00C7"]]}, + +{"description": "Valid numeric entity character U+00C8", +"input": "È", +"output": [["Character", "\u00C8"]]}, + +{"description": "Valid numeric entity character U+00C9", +"input": "É", +"output": [["Character", "\u00C9"]]}, + +{"description": "Valid numeric entity character U+00CA", +"input": "Ê", +"output": [["Character", "\u00CA"]]}, + +{"description": "Valid numeric entity character U+00CB", +"input": "Ë", +"output": [["Character", "\u00CB"]]}, + +{"description": "Valid numeric entity character U+00CC", +"input": "Ì", +"output": [["Character", "\u00CC"]]}, + +{"description": "Valid numeric entity character U+00CD", +"input": "Í", +"output": [["Character", "\u00CD"]]}, + +{"description": "Valid numeric entity character U+00CE", +"input": "Î", +"output": [["Character", "\u00CE"]]}, + +{"description": "Valid numeric entity character U+00CF", +"input": "Ï", +"output": [["Character", "\u00CF"]]}, + +{"description": "Valid numeric entity character U+00D0", +"input": "Ð", +"output": [["Character", "\u00D0"]]}, + +{"description": "Valid numeric entity character U+00D1", +"input": "Ñ", +"output": [["Character", "\u00D1"]]}, + +{"description": "Valid numeric entity character U+00D2", +"input": "Ò", +"output": [["Character", "\u00D2"]]}, + +{"description": "Valid numeric entity character U+00D3", +"input": "Ó", +"output": [["Character", "\u00D3"]]}, + +{"description": "Valid numeric entity character U+00D4", +"input": "Ô", +"output": [["Character", "\u00D4"]]}, + +{"description": "Valid numeric entity character U+00D5", +"input": "Õ", +"output": [["Character", "\u00D5"]]}, + +{"description": "Valid numeric entity character U+00D6", +"input": "Ö", +"output": [["Character", "\u00D6"]]}, + +{"description": "Valid numeric entity character U+00D7", +"input": "×", +"output": [["Character", "\u00D7"]]}, + +{"description": "Valid numeric entity character U+00D8", +"input": "Ø", +"output": [["Character", "\u00D8"]]}, + +{"description": "Valid numeric entity character U+00D9", +"input": "Ù", +"output": [["Character", "\u00D9"]]}, + +{"description": "Valid numeric entity character U+00DA", +"input": "Ú", +"output": [["Character", "\u00DA"]]}, + +{"description": "Valid numeric entity character U+00DB", +"input": "Û", +"output": [["Character", "\u00DB"]]}, + +{"description": "Valid numeric entity character U+00DC", +"input": "Ü", +"output": [["Character", "\u00DC"]]}, + +{"description": "Valid numeric entity character U+00DD", +"input": "Ý", +"output": [["Character", "\u00DD"]]}, + +{"description": "Valid numeric entity character U+00DE", +"input": "Þ", +"output": [["Character", "\u00DE"]]}, + +{"description": "Valid numeric entity character U+00DF", +"input": "ß", +"output": [["Character", "\u00DF"]]}, + +{"description": "Valid numeric entity character U+00E0", +"input": "à", +"output": [["Character", "\u00E0"]]}, + +{"description": "Valid numeric entity character U+00E1", +"input": "á", +"output": [["Character", "\u00E1"]]}, + +{"description": "Valid numeric entity character U+00E2", +"input": "â", +"output": [["Character", "\u00E2"]]}, + +{"description": "Valid numeric entity character U+00E3", +"input": "ã", +"output": [["Character", "\u00E3"]]}, + +{"description": "Valid numeric entity character U+00E4", +"input": "ä", +"output": [["Character", "\u00E4"]]}, + +{"description": "Valid numeric entity character U+00E5", +"input": "å", +"output": [["Character", "\u00E5"]]}, + +{"description": "Valid numeric entity character U+00E6", +"input": "æ", +"output": [["Character", "\u00E6"]]}, + +{"description": "Valid numeric entity character U+00E7", +"input": "ç", +"output": [["Character", "\u00E7"]]}, + +{"description": "Valid numeric entity character U+00E8", +"input": "è", +"output": [["Character", "\u00E8"]]}, + +{"description": "Valid numeric entity character U+00E9", +"input": "é", +"output": [["Character", "\u00E9"]]}, + +{"description": "Valid numeric entity character U+00EA", +"input": "ê", +"output": [["Character", "\u00EA"]]}, + +{"description": "Valid numeric entity character U+00EB", +"input": "ë", +"output": [["Character", "\u00EB"]]}, + +{"description": "Valid numeric entity character U+00EC", +"input": "ì", +"output": [["Character", "\u00EC"]]}, + +{"description": "Valid numeric entity character U+00ED", +"input": "í", +"output": [["Character", "\u00ED"]]}, + +{"description": "Valid numeric entity character U+00EE", +"input": "î", +"output": [["Character", "\u00EE"]]}, + +{"description": "Valid numeric entity character U+00EF", +"input": "ï", +"output": [["Character", "\u00EF"]]}, + +{"description": "Valid numeric entity character U+00F0", +"input": "ð", +"output": [["Character", "\u00F0"]]}, + +{"description": "Valid numeric entity character U+00F1", +"input": "ñ", +"output": [["Character", "\u00F1"]]}, + +{"description": "Valid numeric entity character U+00F2", +"input": "ò", +"output": [["Character", "\u00F2"]]}, + +{"description": "Valid numeric entity character U+00F3", +"input": "ó", +"output": [["Character", "\u00F3"]]}, + +{"description": "Valid numeric entity character U+00F4", +"input": "ô", +"output": [["Character", "\u00F4"]]}, + +{"description": "Valid numeric entity character U+00F5", +"input": "õ", +"output": [["Character", "\u00F5"]]}, + +{"description": "Valid numeric entity character U+00F6", +"input": "ö", +"output": [["Character", "\u00F6"]]}, + +{"description": "Valid numeric entity character U+00F7", +"input": "÷", +"output": [["Character", "\u00F7"]]}, + +{"description": "Valid numeric entity character U+00F8", +"input": "ø", +"output": [["Character", "\u00F8"]]}, + +{"description": "Valid numeric entity character U+00F9", +"input": "ù", +"output": [["Character", "\u00F9"]]}, + +{"description": "Valid numeric entity character U+00FA", +"input": "ú", +"output": [["Character", "\u00FA"]]}, + +{"description": "Valid numeric entity character U+00FB", +"input": "û", +"output": [["Character", "\u00FB"]]}, + +{"description": "Valid numeric entity character U+00FC", +"input": "ü", +"output": [["Character", "\u00FC"]]}, + +{"description": "Valid numeric entity character U+00FD", +"input": "ý", +"output": [["Character", "\u00FD"]]}, + +{"description": "Valid numeric entity character U+00FE", +"input": "þ", +"output": [["Character", "\u00FE"]]}, + +{"description": "Valid numeric entity character U+00FF", +"input": "ÿ", +"output": [["Character", "\u00FF"]]}, + +{"description": "Valid numeric entity character U+D7FF", +"input": "퟿", +"output": [["Character", "\uD7FF"]]}, + +{"description": "Valid numeric entity character U+E000", +"input": "", +"output": [["Character", "\uE000"]]}, + +{"description": "Valid numeric entity character U+FDCF", +"input": "﷏", +"output": [["Character", "\uFDCF"]]}, + +{"description": "Valid numeric entity character U+FDF0", +"input": "ﷰ", +"output": [["Character", "\uFDF0"]]}, + +{"description": "Valid numeric entity character U+FFFD", +"input": "�", +"output": [["Character", "\uFFFD"]]}, + +{"description": "Valid numeric entity character U+10000", +"input": "𐀀", +"output": [["Character", "\uD800\uDC00"]]}, + +{"description": "Valid numeric entity character U+1FFFD", +"input": "🿽", +"output": [["Character", "\uD83F\uDFFD"]]}, + +{"description": "Valid numeric entity character U+20000", +"input": "𠀀", +"output": [["Character", "\uD840\uDC00"]]}, + +{"description": "Valid numeric entity character U+2FFFD", +"input": "𯿽", +"output": [["Character", "\uD87F\uDFFD"]]}, + +{"description": "Valid numeric entity character U+30000", +"input": "𰀀", +"output": [["Character", "\uD880\uDC00"]]}, + +{"description": "Valid numeric entity character U+3FFFD", +"input": "𿿽", +"output": [["Character", "\uD8BF\uDFFD"]]}, + +{"description": "Valid numeric entity character U+40000", +"input": "񀀀", +"output": [["Character", "\uD8C0\uDC00"]]}, + +{"description": "Valid numeric entity character U+4FFFD", +"input": "񏿽", +"output": [["Character", "\uD8FF\uDFFD"]]}, + +{"description": "Valid numeric entity character U+50000", +"input": "񐀀", +"output": [["Character", "\uD900\uDC00"]]}, + +{"description": "Valid numeric entity character U+5FFFD", +"input": "񟿽", +"output": [["Character", "\uD93F\uDFFD"]]}, + +{"description": "Valid numeric entity character U+60000", +"input": "񠀀", +"output": [["Character", "\uD940\uDC00"]]}, + +{"description": "Valid numeric entity character U+6FFFD", +"input": "񯿽", +"output": [["Character", "\uD97F\uDFFD"]]}, + +{"description": "Valid numeric entity character U+70000", +"input": "񰀀", +"output": [["Character", "\uD980\uDC00"]]}, + +{"description": "Valid numeric entity character U+7FFFD", +"input": "񿿽", +"output": [["Character", "\uD9BF\uDFFD"]]}, + +{"description": "Valid numeric entity character U+80000", +"input": "򀀀", +"output": [["Character", "\uD9C0\uDC00"]]}, + +{"description": "Valid numeric entity character U+8FFFD", +"input": "򏿽", +"output": [["Character", "\uD9FF\uDFFD"]]}, + +{"description": "Valid numeric entity character U+90000", +"input": "򐀀", +"output": [["Character", "\uDA00\uDC00"]]}, + +{"description": "Valid numeric entity character U+9FFFD", +"input": "򟿽", +"output": [["Character", "\uDA3F\uDFFD"]]}, + +{"description": "Valid numeric entity character U+A0000", +"input": "򠀀", +"output": [["Character", "\uDA40\uDC00"]]}, + +{"description": "Valid numeric entity character U+AFFFD", +"input": "򯿽", +"output": [["Character", "\uDA7F\uDFFD"]]}, + +{"description": "Valid numeric entity character U+B0000", +"input": "򰀀", +"output": [["Character", "\uDA80\uDC00"]]}, + +{"description": "Valid numeric entity character U+BFFFD", +"input": "򿿽", +"output": [["Character", "\uDABF\uDFFD"]]}, + +{"description": "Valid numeric entity character U+C0000", +"input": "󀀀", +"output": [["Character", "\uDAC0\uDC00"]]}, + +{"description": "Valid numeric entity character U+CFFFD", +"input": "󏿽", +"output": [["Character", "\uDAFF\uDFFD"]]}, + +{"description": "Valid numeric entity character U+D0000", +"input": "󐀀", +"output": [["Character", "\uDB00\uDC00"]]}, + +{"description": "Valid numeric entity character U+DFFFD", +"input": "󟿽", +"output": [["Character", "\uDB3F\uDFFD"]]}, + +{"description": "Valid numeric entity character U+E0000", +"input": "󠀀", +"output": [["Character", "\uDB40\uDC00"]]}, + +{"description": "Valid numeric entity character U+EFFFD", +"input": "󯿽", +"output": [["Character", "\uDB7F\uDFFD"]]}, + +{"description": "Valid numeric entity character U+F0000", +"input": "󰀀", +"output": [["Character", "\uDB80\uDC00"]]}, + +{"description": "Valid numeric entity character U+FFFFD", +"input": "󿿽", +"output": [["Character", "\uDBBF\uDFFD"]]}, + +{"description": "Valid numeric entity character U+100000", +"input": "􀀀", +"output": [["Character", "\uDBC0\uDC00"]]}, + +{"description": "Valid numeric entity character U+10FFFD", +"input": "􏿽", +"output": [["Character", "\uDBFF\uDFFD"]]} + +]} + + diff --git a/tests/data/tokenizer/pendingSpecChanges.test b/tests/data/tokenizer/pendingSpecChanges.test new file mode 100644 index 0000000..1b7dc3c --- /dev/null +++ b/tests/data/tokenizer/pendingSpecChanges.test @@ -0,0 +1,7 @@ +{"tests": [ + +{"description":"", + "output":[["Comment", "comment"]]}, + +{"description":"Comment, Central dash no space", + "input":"", + "output":["ParseError", ["Comment", "-"]]}, + +{"description":"Comment, two central dashes", +"input":"", +"output":["ParseError", ["Comment", " --comment "]]}, + +{"description":"Unfinished comment", +"input":"", + "output":["ParseError", ["Comment", ""]]}, + +{"description":"Short comment two", + "input":"", + "output":["ParseError", ["Comment", ""]]}, + +{"description":"Short comment three", + "input":"", + "output":[["Comment", ""]]}, + + +{"description":"Ampersand EOF", +"input":"&", +"output":[["Character", "&"]]}, + +{"description":"Ampersand ampersand EOF", +"input":"&&", +"output":[["Character", "&&"]]}, + +{"description":"Ampersand space EOF", +"input":"& ", +"output":[["Character", "& "]]}, + +{"description":"Unfinished entity", +"input":"&f", +"output":["ParseError", ["Character", "&f"]]}, + +{"description":"Ampersand, number sign", +"input":"&#", +"output":["ParseError", ["Character", "&#"]]}, + +{"description":"Unfinished numeric entity", +"input":"&#x", +"output":["ParseError", ["Character", "&#x"]]}, + +{"description":"Entity with trailing semicolon (1)", +"input":"I'm ¬it", +"output":[["Character","I'm \u00ACit"]]}, + +{"description":"Entity with trailing semicolon (2)", +"input":"I'm ∉", +"output":[["Character","I'm \u2209"]]}, + +{"description":"Entity without trailing semicolon (1)", +"input":"I'm ¬it", +"output":[["Character","I'm "], "ParseError", ["Character", "\u00ACit"]]}, + +{"description":"Entity without trailing semicolon (2)", +"input":"I'm ¬in", +"output":[["Character","I'm "], "ParseError", ["Character", "\u00ACin"]]}, + +{"description":"Partial entity match at end of file", +"input":"I'm &no", +"output":[["Character","I'm "], "ParseError", ["Character", "&no"]]}, + +{"description":"Non-ASCII character reference name", +"input":"&\u00AC;", +"output":["ParseError", ["Character", "&\u00AC;"]]}, + +{"description":"ASCII decimal entity", +"input":"$", +"output":[["Character","$"]]}, + +{"description":"ASCII hexadecimal entity", +"input":"?", +"output":[["Character","?"]]}, + +{"description":"Hexadecimal entity in attribute", +"input":"", +"output":[["StartTag", "h", {"a":"?"}], ["EndTag", "h"]]}, + +{"description":"Entity in attribute without semicolon ending in x", +"input":"", +"output":["ParseError", ["StartTag", "h", {"a":"¬x"}]]}, + +{"description":"Entity in attribute without semicolon ending in 1", +"input":"", +"output":["ParseError", ["StartTag", "h", {"a":"¬1"}]]}, + +{"description":"Entity in attribute without semicolon ending in i", +"input":"", +"output":["ParseError", ["StartTag", "h", {"a":"¬i"}]]}, + +{"description":"Entity in attribute without semicolon", +"input":"", +"output":["ParseError", ["StartTag", "h", {"a":"\u00A9"}]]}, + +{"description":"Unquoted attribute ending in ampersand", +"input":"", +"output":[["StartTag","s",{"o":"&","t":""}]]}, + +{"description":"Unquoted attribute at end of tag with final character of &, with tag followed by characters", +"input":"foo", +"output":[["StartTag", "a", {"a":"a&"}], ["Character", "foo"]]}, + +{"description":"plaintext element", + "input":"foobar", + "output":[["StartTag","plaintext",{}], ["Character","foobar"]]}, + +{"description":"Open angled bracket in unquoted attribute value state", + "input":"<a a=f<>", + "output":["ParseError", ["StartTag", "a", {"a":"f<"}]]} + +]} diff --git a/tests/data/tokenizer/test2.test b/tests/data/tokenizer/test2.test new file mode 100644 index 0000000..e157514 --- /dev/null +++ b/tests/data/tokenizer/test2.test @@ -0,0 +1,179 @@ +{"tests": [ + +{"description":"DOCTYPE without name", +"input":"<!DOCTYPE>", +"output":["ParseError", "ParseError", ["DOCTYPE", "", null, null, false]]}, + +{"description":"DOCTYPE without space before name", +"input":"<!DOCTYPEhtml>", +"output":["ParseError", ["DOCTYPE", "html", null, null, true]]}, + +{"description":"Incorrect DOCTYPE without a space before name", +"input":"<!DOCTYPEfoo>", +"output":["ParseError", ["DOCTYPE", "foo", null, null, true]]}, + +{"description":"DOCTYPE with publicId", +"input":"<!DOCTYPE html PUBLIC \"-//W3C//DTD HTML Transitional 4.01//EN\">", +"output":[["DOCTYPE", "html", "-//W3C//DTD HTML Transitional 4.01//EN", null, true]]}, + +{"description":"DOCTYPE with EOF after PUBLIC", +"input":"<!DOCTYPE html PUBLIC", +"output":["ParseError", ["DOCTYPE", "html", null, null, false]]}, + +{"description":"DOCTYPE with EOF after PUBLIC '", +"input":"<!DOCTYPE html PUBLIC '", +"output":["ParseError", ["DOCTYPE", "html", "", null, false]]}, + +{"description":"DOCTYPE with EOF after PUBLIC 'x", +"input":"<!DOCTYPE html PUBLIC 'x", +"output":["ParseError", ["DOCTYPE", "html", "x", null, false]]}, + +{"description":"DOCTYPE with systemId", +"input":"<!DOCTYPE html SYSTEM \"-//W3C//DTD HTML Transitional 4.01//EN\">", +"output":[["DOCTYPE", "html", null, "-//W3C//DTD HTML Transitional 4.01//EN", true]]}, + +{"description":"DOCTYPE with publicId and systemId", +"input":"<!DOCTYPE html PUBLIC \"-//W3C//DTD HTML Transitional 4.01//EN\" \"-//W3C//DTD HTML Transitional 4.01//EN\">", +"output":[["DOCTYPE", "html", "-//W3C//DTD HTML Transitional 4.01//EN", "-//W3C//DTD HTML Transitional 4.01//EN", true]]}, + +{"description":"DOCTYPE with > in double-quoted publicId", +"input":"<!DOCTYPE html PUBLIC \">x", +"output":["ParseError", ["DOCTYPE", "html", "", null, false], ["Character", "x"]]}, + +{"description":"DOCTYPE with > in single-quoted publicId", +"input":"<!DOCTYPE html PUBLIC '>x", +"output":["ParseError", ["DOCTYPE", "html", "", null, false], ["Character", "x"]]}, + +{"description":"DOCTYPE with > in double-quoted systemId", +"input":"<!DOCTYPE html PUBLIC \"foo\" \">x", +"output":["ParseError", ["DOCTYPE", "html", "foo", "", false], ["Character", "x"]]}, + +{"description":"DOCTYPE with > in single-quoted systemId", +"input":"<!DOCTYPE html PUBLIC 'foo' '>x", +"output":["ParseError", ["DOCTYPE", "html", "foo", "", false], ["Character", "x"]]}, + +{"description":"Incomplete doctype", +"input":"<!DOCTYPE html ", +"output":["ParseError", ["DOCTYPE", "html", null, null, false]]}, + +{"description":"Numeric entity representing the NUL character", +"input":"&#0000;", +"output":["ParseError", ["Character", "\uFFFD"]]}, + +{"description":"Hexadecimal entity representing the NUL character", +"input":"&#x0000;", +"output":["ParseError", ["Character", "\uFFFD"]]}, + +{"description":"Numeric entity representing a codepoint after 1114111 (U+10FFFF)", +"input":"&#2225222;", +"output":["ParseError", ["Character", "\uFFFD"]]}, + +{"description":"Hexadecimal entity representing a codepoint after 1114111 (U+10FFFF)", +"input":"&#x1010FFFF;", +"output":["ParseError", ["Character", "\uFFFD"]]}, + +{"description":"Hexadecimal entity pair representing a surrogate pair", +"input":"&#xD869;&#xDED6;", +"output":["ParseError", ["Character", "\uFFFD"], "ParseError", ["Character", "\uFFFD"]]}, + +{"description":"Hexadecimal entity with mixed uppercase and lowercase", +"input":"&#xaBcD;", +"output":[["Character", "\uABCD"]]}, + +{"description":"Entity without a name", +"input":"&;", +"output":["ParseError", ["Character", "&;"]]}, + +{"description":"Unescaped ampersand in attribute value", +"input":"<h a='&'>", +"output":[["StartTag", "h", { "a":"&" }]]}, + +{"description":"StartTag containing <", +"input":"<a<b>", +"output":[["StartTag", "a<b", { }]]}, + +{"description":"Non-void element containing trailing /", +"input":"<h/>", +"output":[["StartTag","h",{},true]]}, + +{"description":"Void element with permitted slash", +"input":"<br/>", +"output":[["StartTag","br",{},true]]}, + +{"description":"Void element with permitted slash (with attribute)", +"input":"<br foo='bar'/>", +"output":[["StartTag","br",{"foo":"bar"},true]]}, + +{"description":"StartTag containing /", +"input":"<h/a='b'>", +"output":["ParseError", ["StartTag", "h", { "a":"b" }]]}, + +{"description":"Double-quoted attribute value", +"input":"<h a=\"b\">", +"output":[["StartTag", "h", { "a":"b" }]]}, + +{"description":"Unescaped </", +"input":"</", +"output":["ParseError", ["Character", "</"]]}, + +{"description":"Illegal end tag name", +"input":"</1>", +"output":["ParseError", ["Comment", "1"]]}, + +{"description":"Simili processing instruction", +"input":"<?namespace>", +"output":["ParseError", ["Comment", "?namespace"]]}, + +{"description":"A bogus comment stops at >, even if preceeded by two dashes", +"input":"<?foo-->", +"output":["ParseError", ["Comment", "?foo--"]]}, + +{"description":"Unescaped <", +"input":"foo < bar", +"output":[["Character", "foo "], "ParseError", ["Character", "< bar"]]}, + +{"description":"Null Byte Replacement", +"input":"\u0000", +"output":["ParseError", ["Character", "\u0000"]]}, + +{"description":"Comment with dash", +"input":"<!---x", +"output":["ParseError", ["Comment", "-x"]]}, + +{"description":"Entity + newline", +"input":"\nx\n&gt;\n", +"output":[["Character","\nx\n>\n"]]}, + +{"description":"Start tag with no attributes but space before the greater-than sign", +"input":"<h >", +"output":[["StartTag", "h", {}]]}, + +{"description":"Empty attribute followed by uppercase attribute", +"input":"<h a B=''>", +"output":[["StartTag", "h", {"a":"", "b":""}]]}, + +{"description":"Double-quote after attribute name", +"input":"<h a \">", +"output":["ParseError", ["StartTag", "h", {"a":"", "\"":""}]]}, + +{"description":"Single-quote after attribute name", +"input":"<h a '>", +"output":["ParseError", ["StartTag", "h", {"a":"", "'":""}]]}, + +{"description":"Empty end tag with following characters", +"input":"a</>bc", +"output":[["Character", "a"], "ParseError", ["Character", "bc"]]}, + +{"description":"Empty end tag with following tag", +"input":"a</><b>c", +"output":[["Character", "a"], "ParseError", ["StartTag", "b", {}], ["Character", "c"]]}, + +{"description":"Empty end tag with following comment", +"input":"a</><!--b-->c", +"output":[["Character", "a"], "ParseError", ["Comment", "b"], ["Character", "c"]]}, + +{"description":"Empty end tag with following end tag", +"input":"a</></b>c", +"output":[["Character", "a"], "ParseError", ["EndTag", "b"], ["Character", "c"]]} + +]} diff --git a/tests/data/tokenizer/test3.test b/tests/data/tokenizer/test3.test new file mode 100644 index 0000000..58519e8 --- /dev/null +++ b/tests/data/tokenizer/test3.test @@ -0,0 +1,6047 @@ +{"tests": [ + +{"description":"", +"input":"", +"output":[]}, + +{"description":"\\u0009", +"input":"\u0009", +"output":[["Character", "\u0009"]]}, + +{"description":"\\u000A", +"input":"\u000A", +"output":[["Character", "\u000A"]]}, + +{"description":"\\u000B", +"input":"\u000B", +"output":["ParseError", ["Character", "\u000B"]]}, + +{"description":"\\u000C", +"input":"\u000C", +"output":[["Character", "\u000C"]]}, + +{"description":" ", +"input":" ", +"output":[["Character", " "]]}, + +{"description":"!", +"input":"!", +"output":[["Character", "!"]]}, + +{"description":"\"", +"input":"\"", +"output":[["Character", "\""]]}, + +{"description":"%", +"input":"%", +"output":[["Character", "%"]]}, + +{"description":"&", +"input":"&", +"output":[["Character", "&"]]}, + +{"description":"'", +"input":"'", +"output":[["Character", "'"]]}, + +{"description":",", +"input":",", +"output":[["Character", ","]]}, + +{"description":"-", +"input":"-", +"output":[["Character", "-"]]}, + +{"description":".", +"input":".", +"output":[["Character", "."]]}, + +{"description":"/", +"input":"/", +"output":[["Character", "/"]]}, + +{"description":"0", +"input":"0", +"output":[["Character", "0"]]}, + +{"description":"1", +"input":"1", +"output":[["Character", "1"]]}, + +{"description":"9", +"input":"9", +"output":[["Character", "9"]]}, + +{"description":";", +"input":";", +"output":[["Character", ";"]]}, + +{"description":"<", +"input":"<", +"output":["ParseError", ["Character", "<"]]}, + +{"description":"<\\u0000", +"input":"<\u0000", +"output":["ParseError", ["Character", "<"], "ParseError", ["Character", "\u0000"]]}, + +{"description":"<\\u0009", +"input":"<\u0009", +"output":["ParseError", ["Character", "<\u0009"]]}, + +{"description":"<\\u000A", +"input":"<\u000A", +"output":["ParseError", ["Character", "<\u000A"]]}, + +{"description":"<\\u000B", +"input":"<\u000B", +"output":["ParseError", "ParseError", ["Character", "<\u000B"]]}, + +{"description":"<\\u000C", +"input":"<\u000C", +"output":["ParseError", ["Character", "<\u000C"]]}, + +{"description":"< ", +"input":"< ", +"output":["ParseError", ["Character", "< "]]}, + +{"description":"<!", +"input":"<!", +"output":["ParseError", ["Comment", ""]]}, + +{"description":"<!\\u0000", +"input":"<!\u0000", +"output":["ParseError", ["Comment", "\uFFFD"]]}, + +{"description":"<!\\u0009", +"input":"<!\u0009", +"output":["ParseError", ["Comment", "\u0009"]]}, + +{"description":"<!\\u000A", +"input":"<!\u000A", +"output":["ParseError", ["Comment", "\u000A"]]}, + +{"description":"<!\\u000B", +"input":"<!\u000B", +"output":["ParseError", "ParseError", ["Comment", "\u000B"]]}, + +{"description":"<!\\u000C", +"input":"<!\u000C", +"output":["ParseError", ["Comment", "\u000C"]]}, + +{"description":"<! ", +"input":"<! ", +"output":["ParseError", ["Comment", " "]]}, + +{"description":"<!!", +"input":"<!!", +"output":["ParseError", ["Comment", "!"]]}, + +{"description":"<!\"", +"input":"<!\"", +"output":["ParseError", ["Comment", "\""]]}, + +{"description":"<!&", +"input":"<!&", +"output":["ParseError", ["Comment", "&"]]}, + +{"description":"<!'", +"input":"<!'", +"output":["ParseError", ["Comment", "'"]]}, + +{"description":"<!-", +"input":"<!-", +"output":["ParseError", ["Comment", "-"]]}, + +{"description":"<!--", +"input":"<!--", +"output":["ParseError", ["Comment", ""]]}, + +{"description":"<!--\\u0000", +"input":"<!--\u0000", +"output":["ParseError", "ParseError", ["Comment", "\uFFFD"]]}, + +{"description":"<!--\\u0009", +"input":"<!--\u0009", +"output":["ParseError", ["Comment", "\u0009"]]}, + +{"description":"<!--\\u000A", +"input":"<!--\u000A", +"output":["ParseError", ["Comment", "\u000A"]]}, + +{"description":"<!--\\u000B", +"input":"<!--\u000B", +"output":["ParseError", "ParseError", ["Comment", "\u000B"]]}, + +{"description":"<!--\\u000C", +"input":"<!--\u000C", +"output":["ParseError", ["Comment", "\u000C"]]}, + +{"description":"<!-- ", +"input":"<!-- ", +"output":["ParseError", ["Comment", " "]]}, + +{"description":"<!-- \\u0000", +"input":"<!-- \u0000", +"output":["ParseError", "ParseError", ["Comment", " \uFFFD"]]}, + +{"description":"<!-- \\u0009", +"input":"<!-- \u0009", +"output":["ParseError", ["Comment", " \u0009"]]}, + +{"description":"<!-- \\u000A", +"input":"<!-- \u000A", +"output":["ParseError", ["Comment", " \u000A"]]}, + +{"description":"<!-- \\u000B", +"input":"<!-- \u000B", +"output":["ParseError", "ParseError", ["Comment", " \u000B"]]}, + +{"description":"<!-- \\u000C", +"input":"<!-- \u000C", +"output":["ParseError", ["Comment", " \u000C"]]}, + +{"description":"<!-- ", +"input":"<!-- ", +"output":["ParseError", ["Comment", " "]]}, + +{"description":"<!-- !", +"input":"<!-- !", +"output":["ParseError", ["Comment", " !"]]}, + +{"description":"<!-- \"", +"input":"<!-- \"", +"output":["ParseError", ["Comment", " \""]]}, + +{"description":"<!-- &", +"input":"<!-- &", +"output":["ParseError", ["Comment", " &"]]}, + +{"description":"<!-- '", +"input":"<!-- '", +"output":["ParseError", ["Comment", " '"]]}, + +{"description":"<!-- ,", +"input":"<!-- ,", +"output":["ParseError", ["Comment", " ,"]]}, + +{"description":"<!-- -", +"input":"<!-- -", +"output":["ParseError", ["Comment", " "]]}, + +{"description":"<!-- -\\u0000", +"input":"<!-- -\u0000", +"output":["ParseError", "ParseError", ["Comment", " -\uFFFD"]]}, + +{"description":"<!-- -\\u0009", +"input":"<!-- -\u0009", +"output":["ParseError", ["Comment", " -\u0009"]]}, + +{"description":"<!-- -\\u000A", +"input":"<!-- -\u000A", +"output":["ParseError", ["Comment", " -\u000A"]]}, + +{"description":"<!-- -\\u000B", +"input":"<!-- -\u000B", +"output":["ParseError", "ParseError", ["Comment", " -\u000B"]]}, + +{"description":"<!-- -\\u000C", +"input":"<!-- -\u000C", +"output":["ParseError", ["Comment", " -\u000C"]]}, + +{"description":"<!-- - ", +"input":"<!-- - ", +"output":["ParseError", ["Comment", " - "]]}, + +{"description":"<!-- -!", +"input":"<!-- -!", +"output":["ParseError", ["Comment", " -!"]]}, + +{"description":"<!-- -\"", +"input":"<!-- -\"", +"output":["ParseError", ["Comment", " -\""]]}, + +{"description":"<!-- -&", +"input":"<!-- -&", +"output":["ParseError", ["Comment", " -&"]]}, + +{"description":"<!-- -'", +"input":"<!-- -'", +"output":["ParseError", ["Comment", " -'"]]}, + +{"description":"<!-- -,", +"input":"<!-- -,", +"output":["ParseError", ["Comment", " -,"]]}, + +{"description":"<!-- --", +"input":"<!-- --", +"output":["ParseError", ["Comment", " "]]}, + +{"description":"<!-- -.", +"input":"<!-- -.", +"output":["ParseError", ["Comment", " -."]]}, + +{"description":"<!-- -/", +"input":"<!-- -/", +"output":["ParseError", ["Comment", " -/"]]}, + +{"description":"<!-- -0", +"input":"<!-- -0", +"output":["ParseError", ["Comment", " -0"]]}, + +{"description":"<!-- -1", +"input":"<!-- -1", +"output":["ParseError", ["Comment", " -1"]]}, + +{"description":"<!-- -9", +"input":"<!-- -9", +"output":["ParseError", ["Comment", " -9"]]}, + +{"description":"<!-- -<", +"input":"<!-- -<", +"output":["ParseError", ["Comment", " -<"]]}, + +{"description":"<!-- -=", +"input":"<!-- -=", +"output":["ParseError", ["Comment", " -="]]}, + +{"description":"<!-- ->", +"input":"<!-- ->", +"output":["ParseError", ["Comment", " ->"]]}, + +{"description":"<!-- -?", +"input":"<!-- -?", +"output":["ParseError", ["Comment", " -?"]]}, + +{"description":"<!-- -@", +"input":"<!-- -@", +"output":["ParseError", ["Comment", " -@"]]}, + +{"description":"<!-- -A", +"input":"<!-- -A", +"output":["ParseError", ["Comment", " -A"]]}, + +{"description":"<!-- -B", +"input":"<!-- -B", +"output":["ParseError", ["Comment", " -B"]]}, + +{"description":"<!-- -Y", +"input":"<!-- -Y", +"output":["ParseError", ["Comment", " -Y"]]}, + +{"description":"<!-- -Z", +"input":"<!-- -Z", +"output":["ParseError", ["Comment", " -Z"]]}, + +{"description":"<!-- -`", +"input":"<!-- -`", +"output":["ParseError", ["Comment", " -`"]]}, + +{"description":"<!-- -a", +"input":"<!-- -a", +"output":["ParseError", ["Comment", " -a"]]}, + +{"description":"<!-- -b", +"input":"<!-- -b", +"output":["ParseError", ["Comment", " -b"]]}, + +{"description":"<!-- -y", +"input":"<!-- -y", +"output":["ParseError", ["Comment", " -y"]]}, + +{"description":"<!-- -z", +"input":"<!-- -z", +"output":["ParseError", ["Comment", " -z"]]}, + +{"description":"<!-- -{", +"input":"<!-- -{", +"output":["ParseError", ["Comment", " -{"]]}, + +{"description":"<!-- -\\uDBC0\\uDC00", +"input":"<!-- -\uDBC0\uDC00", +"output":["ParseError", ["Comment", " -\uDBC0\uDC00"]]}, + +{"description":"<!-- .", +"input":"<!-- .", +"output":["ParseError", ["Comment", " ."]]}, + +{"description":"<!-- /", +"input":"<!-- /", +"output":["ParseError", ["Comment", " /"]]}, + +{"description":"<!-- 0", +"input":"<!-- 0", +"output":["ParseError", ["Comment", " 0"]]}, + +{"description":"<!-- 1", +"input":"<!-- 1", +"output":["ParseError", ["Comment", " 1"]]}, + +{"description":"<!-- 9", +"input":"<!-- 9", +"output":["ParseError", ["Comment", " 9"]]}, + +{"description":"<!-- <", +"input":"<!-- <", +"output":["ParseError", ["Comment", " <"]]}, + +{"description":"<!-- =", +"input":"<!-- =", +"output":["ParseError", ["Comment", " ="]]}, + +{"description":"<!-- >", +"input":"<!-- >", +"output":["ParseError", ["Comment", " >"]]}, + +{"description":"<!-- ?", +"input":"<!-- ?", +"output":["ParseError", ["Comment", " ?"]]}, + +{"description":"<!-- @", +"input":"<!-- @", +"output":["ParseError", ["Comment", " @"]]}, + +{"description":"<!-- A", +"input":"<!-- A", +"output":["ParseError", ["Comment", " A"]]}, + +{"description":"<!-- B", +"input":"<!-- B", +"output":["ParseError", ["Comment", " B"]]}, + +{"description":"<!-- Y", +"input":"<!-- Y", +"output":["ParseError", ["Comment", " Y"]]}, + +{"description":"<!-- Z", +"input":"<!-- Z", +"output":["ParseError", ["Comment", " Z"]]}, + +{"description":"<!-- `", +"input":"<!-- `", +"output":["ParseError", ["Comment", " `"]]}, + +{"description":"<!-- a", +"input":"<!-- a", +"output":["ParseError", ["Comment", " a"]]}, + +{"description":"<!-- b", +"input":"<!-- b", +"output":["ParseError", ["Comment", " b"]]}, + +{"description":"<!-- y", +"input":"<!-- y", +"output":["ParseError", ["Comment", " y"]]}, + +{"description":"<!-- z", +"input":"<!-- z", +"output":["ParseError", ["Comment", " z"]]}, + +{"description":"<!-- {", +"input":"<!-- {", +"output":["ParseError", ["Comment", " {"]]}, + +{"description":"<!-- \\uDBC0\\uDC00", +"input":"<!-- \uDBC0\uDC00", +"output":["ParseError", ["Comment", " \uDBC0\uDC00"]]}, + +{"description":"<!--!", +"input":"<!--!", +"output":["ParseError", ["Comment", "!"]]}, + +{"description":"<!--\"", +"input":"<!--\"", +"output":["ParseError", ["Comment", "\""]]}, + +{"description":"<!--&", +"input":"<!--&", +"output":["ParseError", ["Comment", "&"]]}, + +{"description":"<!--'", +"input":"<!--'", +"output":["ParseError", ["Comment", "'"]]}, + +{"description":"<!--,", +"input":"<!--,", +"output":["ParseError", ["Comment", ","]]}, + +{"description":"<!---", +"input":"<!---", +"output":["ParseError", ["Comment", ""]]}, + +{"description":"<!---\\u0000", +"input":"<!---\u0000", +"output":["ParseError", "ParseError", ["Comment", "-\uFFFD"]]}, + +{"description":"<!---\\u0009", +"input":"<!---\u0009", +"output":["ParseError", ["Comment", "-\u0009"]]}, + +{"description":"<!---\\u000A", +"input":"<!---\u000A", +"output":["ParseError", ["Comment", "-\u000A"]]}, + +{"description":"<!---\\u000B", +"input":"<!---\u000B", +"output":["ParseError", "ParseError", ["Comment", "-\u000B"]]}, + +{"description":"<!---\\u000C", +"input":"<!---\u000C", +"output":["ParseError", ["Comment", "-\u000C"]]}, + +{"description":"<!--- ", +"input":"<!--- ", +"output":["ParseError", ["Comment", "- "]]}, + +{"description":"<!---!", +"input":"<!---!", +"output":["ParseError", ["Comment", "-!"]]}, + +{"description":"<!---\"", +"input":"<!---\"", +"output":["ParseError", ["Comment", "-\""]]}, + +{"description":"<!---&", +"input":"<!---&", +"output":["ParseError", ["Comment", "-&"]]}, + +{"description":"<!---'", +"input":"<!---'", +"output":["ParseError", ["Comment", "-'"]]}, + +{"description":"<!---,", +"input":"<!---,", +"output":["ParseError", ["Comment", "-,"]]}, + +{"description":"<!----", +"input":"<!----", +"output":["ParseError", ["Comment", ""]]}, + +{"description":"<!----\\u0000", +"input":"<!----\u0000", +"output":["ParseError", "ParseError", ["Comment", "--\uFFFD"]]}, + +{"description":"<!----\\u0009", +"input":"<!----\u0009", +"output":["ParseError", "ParseError", ["Comment", "--\u0009"]]}, + +{"description":"<!----\\u000A", +"input":"<!----\u000A", +"output":["ParseError", "ParseError", ["Comment", "--\u000A"]]}, + +{"description":"<!----\\u000B", +"input":"<!----\u000B", +"output":["ParseError", "ParseError", "ParseError", ["Comment", "--\u000B"]]}, + +{"description":"<!----\\u000C", +"input":"<!----\u000C", +"output":["ParseError", "ParseError", ["Comment", "--\u000C"]]}, + +{"description":"<!---- ", +"input":"<!---- ", +"output":["ParseError", "ParseError", ["Comment", "-- "]]}, + +{"description":"<!---- -", +"input":"<!---- -", +"output":["ParseError", "ParseError", ["Comment", "-- "]]}, + +{"description":"<!---- --", +"input":"<!---- --", +"output":["ParseError", "ParseError", ["Comment", "-- "]]}, + +{"description":"<!---- -->", +"input":"<!---- -->", +"output":["ParseError", ["Comment", "-- "]]}, + +{"description":"<!---- -->", +"input":"<!---- -->", +"output":["ParseError", ["Comment", "-- "]]}, + +{"description":"<!---- a-->", +"input":"<!---- a-->", +"output":["ParseError", ["Comment", "-- a"]]}, + +{"description":"<!----!", +"input":"<!----!", +"output":["ParseError", "ParseError", ["Comment", ""]]}, + +{"description":"<!----!>", +"input":"<!----!>", +"output":["ParseError", ["Comment", ""]]}, + +{"description":"<!----!a", +"input":"<!----!a", +"output":["ParseError", "ParseError", ["Comment", "--!a"]]}, + +{"description":"<!----!a-", +"input":"<!----!a-", +"output":["ParseError", "ParseError", ["Comment", "--!a"]]}, + +{"description":"<!----!a--", +"input":"<!----!a--", +"output":["ParseError", "ParseError", ["Comment", "--!a"]]}, + +{"description":"<!----!a-->", +"input":"<!----!a-->", +"output":["ParseError", ["Comment", "--!a"]]}, + +{"description":"<!----!-", +"input":"<!----!-", +"output":["ParseError", "ParseError", ["Comment", "--!"]]}, + +{"description":"<!----!--", +"input":"<!----!--", +"output":["ParseError", "ParseError", ["Comment", "--!"]]}, + +{"description":"<!----!-->", +"input":"<!----!-->", +"output":["ParseError", ["Comment", "--!"]]}, + +{"description":"<!----\"", +"input":"<!----\"", +"output":["ParseError", "ParseError", ["Comment", "--\""]]}, + +{"description":"<!----&", +"input":"<!----&", +"output":["ParseError", "ParseError", ["Comment", "--&"]]}, + +{"description":"<!----'", +"input":"<!----'", +"output":["ParseError", "ParseError", ["Comment", "--'"]]}, + +{"description":"<!----,", +"input":"<!----,", +"output":["ParseError", "ParseError", ["Comment", "--,"]]}, + +{"description":"<!-----", +"input":"<!-----", +"output":["ParseError", "ParseError", ["Comment", "-"]]}, + +{"description":"<!----.", +"input":"<!----.", +"output":["ParseError", "ParseError", ["Comment", "--."]]}, + +{"description":"<!----/", +"input":"<!----/", +"output":["ParseError", "ParseError", ["Comment", "--/"]]}, + +{"description":"<!----0", +"input":"<!----0", +"output":["ParseError", "ParseError", ["Comment", "--0"]]}, + +{"description":"<!----1", +"input":"<!----1", +"output":["ParseError", "ParseError", ["Comment", "--1"]]}, + +{"description":"<!----9", +"input":"<!----9", +"output":["ParseError", "ParseError", ["Comment", "--9"]]}, + +{"description":"<!----<", +"input":"<!----<", +"output":["ParseError", "ParseError", ["Comment", "--<"]]}, + +{"description":"<!----=", +"input":"<!----=", +"output":["ParseError", "ParseError", ["Comment", "--="]]}, + +{"description":"<!---->", +"input":"<!---->", +"output":[["Comment", ""]]}, + +{"description":"<!----?", +"input":"<!----?", +"output":["ParseError", "ParseError", ["Comment", "--?"]]}, + +{"description":"<!----@", +"input":"<!----@", +"output":["ParseError", "ParseError", ["Comment", "--@"]]}, + +{"description":"<!----A", +"input":"<!----A", +"output":["ParseError", "ParseError", ["Comment", "--A"]]}, + +{"description":"<!----B", +"input":"<!----B", +"output":["ParseError", "ParseError", ["Comment", "--B"]]}, + +{"description":"<!----Y", +"input":"<!----Y", +"output":["ParseError", "ParseError", ["Comment", "--Y"]]}, + +{"description":"<!----Z", +"input":"<!----Z", +"output":["ParseError", "ParseError", ["Comment", "--Z"]]}, + +{"description":"<!----`", +"input":"<!----`", +"output":["ParseError", "ParseError", ["Comment", "--`"]]}, + +{"description":"<!----a", +"input":"<!----a", +"output":["ParseError", "ParseError", ["Comment", "--a"]]}, + +{"description":"<!----b", +"input":"<!----b", +"output":["ParseError", "ParseError", ["Comment", "--b"]]}, + +{"description":"<!----y", +"input":"<!----y", +"output":["ParseError", "ParseError", ["Comment", "--y"]]}, + +{"description":"<!----z", +"input":"<!----z", +"output":["ParseError", "ParseError", ["Comment", "--z"]]}, + +{"description":"<!----{", +"input":"<!----{", +"output":["ParseError", "ParseError", ["Comment", "--{"]]}, + +{"description":"<!----\\uDBC0\\uDC00", +"input":"<!----\uDBC0\uDC00", +"output":["ParseError", "ParseError", ["Comment", "--\uDBC0\uDC00"]]}, + +{"description":"<!---.", +"input":"<!---.", +"output":["ParseError", ["Comment", "-."]]}, + +{"description":"<!---/", +"input":"<!---/", +"output":["ParseError", ["Comment", "-/"]]}, + +{"description":"<!---0", +"input":"<!---0", +"output":["ParseError", ["Comment", "-0"]]}, + +{"description":"<!---1", +"input":"<!---1", +"output":["ParseError", ["Comment", "-1"]]}, + +{"description":"<!---9", +"input":"<!---9", +"output":["ParseError", ["Comment", "-9"]]}, + +{"description":"<!---<", +"input":"<!---<", +"output":["ParseError", ["Comment", "-<"]]}, + +{"description":"<!---=", +"input":"<!---=", +"output":["ParseError", ["Comment", "-="]]}, + +{"description":"<!--->", +"input":"<!--->", +"output":["ParseError", ["Comment", ""]]}, + +{"description":"<!---?", +"input":"<!---?", +"output":["ParseError", ["Comment", "-?"]]}, + +{"description":"<!---@", +"input":"<!---@", +"output":["ParseError", ["Comment", "-@"]]}, + +{"description":"<!---A", +"input":"<!---A", +"output":["ParseError", ["Comment", "-A"]]}, + +{"description":"<!---B", +"input":"<!---B", +"output":["ParseError", ["Comment", "-B"]]}, + +{"description":"<!---Y", +"input":"<!---Y", +"output":["ParseError", ["Comment", "-Y"]]}, + +{"description":"<!---Z", +"input":"<!---Z", +"output":["ParseError", ["Comment", "-Z"]]}, + +{"description":"<!---`", +"input":"<!---`", +"output":["ParseError", ["Comment", "-`"]]}, + +{"description":"<!---a", +"input":"<!---a", +"output":["ParseError", ["Comment", "-a"]]}, + +{"description":"<!---b", +"input":"<!---b", +"output":["ParseError", ["Comment", "-b"]]}, + +{"description":"<!---y", +"input":"<!---y", +"output":["ParseError", ["Comment", "-y"]]}, + +{"description":"<!---z", +"input":"<!---z", +"output":["ParseError", ["Comment", "-z"]]}, + +{"description":"<!---{", +"input":"<!---{", +"output":["ParseError", ["Comment", "-{"]]}, + +{"description":"<!---\\uDBC0\\uDC00", +"input":"<!---\uDBC0\uDC00", +"output":["ParseError", ["Comment", "-\uDBC0\uDC00"]]}, + +{"description":"<!--.", +"input":"<!--.", +"output":["ParseError", ["Comment", "."]]}, + +{"description":"<!--/", +"input":"<!--/", +"output":["ParseError", ["Comment", "/"]]}, + +{"description":"<!--0", +"input":"<!--0", +"output":["ParseError", ["Comment", "0"]]}, + +{"description":"<!--1", +"input":"<!--1", +"output":["ParseError", ["Comment", "1"]]}, + +{"description":"<!--9", +"input":"<!--9", +"output":["ParseError", ["Comment", "9"]]}, + +{"description":"<!--<", +"input":"<!--<", +"output":["ParseError", ["Comment", "<"]]}, + +{"description":"<!--=", +"input":"<!--=", +"output":["ParseError", ["Comment", "="]]}, + +{"description":"<!-->", +"input":"<!-->", +"output":["ParseError", ["Comment", ""]]}, + +{"description":"<!--?", +"input":"<!--?", +"output":["ParseError", ["Comment", "?"]]}, + +{"description":"<!--@", +"input":"<!--@", +"output":["ParseError", ["Comment", "@"]]}, + +{"description":"<!--A", +"input":"<!--A", +"output":["ParseError", ["Comment", "A"]]}, + +{"description":"<!--B", +"input":"<!--B", +"output":["ParseError", ["Comment", "B"]]}, + +{"description":"<!--Y", +"input":"<!--Y", +"output":["ParseError", ["Comment", "Y"]]}, + +{"description":"<!--Z", +"input":"<!--Z", +"output":["ParseError", ["Comment", "Z"]]}, + +{"description":"<!--`", +"input":"<!--`", +"output":["ParseError", ["Comment", "`"]]}, + +{"description":"<!--a", +"input":"<!--a", +"output":["ParseError", ["Comment", "a"]]}, + +{"description":"<!--b", +"input":"<!--b", +"output":["ParseError", ["Comment", "b"]]}, + +{"description":"<!--y", +"input":"<!--y", +"output":["ParseError", ["Comment", "y"]]}, + +{"description":"<!--z", +"input":"<!--z", +"output":["ParseError", ["Comment", "z"]]}, + +{"description":"<!--{", +"input":"<!--{", +"output":["ParseError", ["Comment", "{"]]}, + +{"description":"<!--\\uDBC0\\uDC00", +"input":"<!--\uDBC0\uDC00", +"output":["ParseError", ["Comment", "\uDBC0\uDC00"]]}, + +{"description":"<!/", +"input":"<!/", +"output":["ParseError", ["Comment", "/"]]}, + +{"description":"<!0", +"input":"<!0", +"output":["ParseError", ["Comment", "0"]]}, + +{"description":"<!1", +"input":"<!1", +"output":["ParseError", ["Comment", "1"]]}, + +{"description":"<!9", +"input":"<!9", +"output":["ParseError", ["Comment", "9"]]}, + +{"description":"<!<", +"input":"<!<", +"output":["ParseError", ["Comment", "<"]]}, + +{"description":"<!=", +"input":"<!=", +"output":["ParseError", ["Comment", "="]]}, + +{"description":"<!>", +"input":"<!>", +"output":["ParseError", ["Comment", ""]]}, + +{"description":"<!?", +"input":"<!?", +"output":["ParseError", ["Comment", "?"]]}, + +{"description":"<!@", +"input":"<!@", +"output":["ParseError", ["Comment", "@"]]}, + +{"description":"<!A", +"input":"<!A", +"output":["ParseError", ["Comment", "A"]]}, + +{"description":"<!B", +"input":"<!B", +"output":["ParseError", ["Comment", "B"]]}, + +{"description":"<!DOCTYPE", +"input":"<!DOCTYPE", +"output":["ParseError", ["DOCTYPE", "", null, null, false]]}, + +{"description":"<!DOCTYPE\\u0000", +"input":"<!DOCTYPE\u0000", +"output":["ParseError", "ParseError", "ParseError", ["DOCTYPE", "\uFFFD", null, null, false]]}, + +{"description":"<!DOCTYPE\\u0008", +"input":"<!DOCTYPE\u0008", +"output":["ParseError", "ParseError", "ParseError", ["DOCTYPE", "\u0008", null, null, false]]}, + +{"description":"<!DOCTYPE\\u0009", +"input":"<!DOCTYPE\u0009", +"output":["ParseError", ["DOCTYPE", "", null, null, false]]}, + +{"description":"<!DOCTYPE\\u000A", +"input":"<!DOCTYPE\u000A", +"output":["ParseError", ["DOCTYPE", "", null, null, false]]}, + +{"description":"<!DOCTYPE\\u000B", +"input":"<!DOCTYPE\u000B", +"output":["ParseError", "ParseError", "ParseError", ["DOCTYPE", "\u000B", null, null, false]]}, + +{"description":"<!DOCTYPE\\u000C", +"input":"<!DOCTYPE\u000C", +"output":["ParseError", ["DOCTYPE", "", null, null, false]]}, + +{"description":"<!DOCTYPE\\u000D", +"input":"<!DOCTYPE\u000D", +"output":["ParseError", ["DOCTYPE", "", null, null, false]]}, + +{"description":"<!DOCTYPE\\u001F", +"input":"<!DOCTYPE\u001F", +"output":["ParseError", "ParseError", "ParseError", ["DOCTYPE", "\u001F", null, null, false]]}, + +{"description":"<!DOCTYPE ", +"input":"<!DOCTYPE ", +"output":["ParseError", ["DOCTYPE", "", null, null, false]]}, + +{"description":"<!DOCTYPE \\u0000", +"input":"<!DOCTYPE \u0000", +"output":["ParseError", "ParseError", ["DOCTYPE", "\uFFFD", null, null, false]]}, + +{"description":"<!DOCTYPE \\u0008", +"input":"<!DOCTYPE \u0008", +"output":["ParseError", "ParseError", ["DOCTYPE", "\u0008", null, null, false]]}, + +{"description":"<!DOCTYPE \\u0009", +"input":"<!DOCTYPE \u0009", +"output":["ParseError", ["DOCTYPE", "", null, null, false]]}, + +{"description":"<!DOCTYPE \\u000A", +"input":"<!DOCTYPE \u000A", +"output":["ParseError", ["DOCTYPE", "", null, null, false]]}, + +{"description":"<!DOCTYPE \\u000B", +"input":"<!DOCTYPE \u000B", +"output":["ParseError", "ParseError", ["DOCTYPE", "\u000B", null, null, false]]}, + +{"description":"<!DOCTYPE \\u000C", +"input":"<!DOCTYPE \u000C", +"output":["ParseError", ["DOCTYPE", "", null, null, false]]}, + +{"description":"<!DOCTYPE \\u000D", +"input":"<!DOCTYPE \u000D", +"output":["ParseError", ["DOCTYPE", "", null, null, false]]}, + +{"description":"<!DOCTYPE \\u001F", +"input":"<!DOCTYPE \u001F", +"output":["ParseError", "ParseError", ["DOCTYPE", "\u001F", null, null, false]]}, + +{"description":"<!DOCTYPE ", +"input":"<!DOCTYPE ", +"output":["ParseError", ["DOCTYPE", "", null, null, false]]}, + +{"description":"<!DOCTYPE !", +"input":"<!DOCTYPE !", +"output":["ParseError", ["DOCTYPE", "!", null, null, false]]}, + +{"description":"<!DOCTYPE \"", +"input":"<!DOCTYPE \"", +"output":["ParseError", ["DOCTYPE", "\"", null, null, false]]}, + +{"description":"<!DOCTYPE &", +"input":"<!DOCTYPE &", +"output":["ParseError", ["DOCTYPE", "&", null, null, false]]}, + +{"description":"<!DOCTYPE '", +"input":"<!DOCTYPE '", +"output":["ParseError", ["DOCTYPE", "'", null, null, false]]}, + +{"description":"<!DOCTYPE -", +"input":"<!DOCTYPE -", +"output":["ParseError", ["DOCTYPE", "-", null, null, false]]}, + +{"description":"<!DOCTYPE /", +"input":"<!DOCTYPE /", +"output":["ParseError", ["DOCTYPE", "/", null, null, false]]}, + +{"description":"<!DOCTYPE 0", +"input":"<!DOCTYPE 0", +"output":["ParseError", ["DOCTYPE", "0", null, null, false]]}, + +{"description":"<!DOCTYPE 1", +"input":"<!DOCTYPE 1", +"output":["ParseError", ["DOCTYPE", "1", null, null, false]]}, + +{"description":"<!DOCTYPE 9", +"input":"<!DOCTYPE 9", +"output":["ParseError", ["DOCTYPE", "9", null, null, false]]}, + +{"description":"<!DOCTYPE <", +"input":"<!DOCTYPE <", +"output":["ParseError", ["DOCTYPE", "<", null, null, false]]}, + +{"description":"<!DOCTYPE =", +"input":"<!DOCTYPE =", +"output":["ParseError", ["DOCTYPE", "=", null, null, false]]}, + +{"description":"<!DOCTYPE >", +"input":"<!DOCTYPE >", +"output":["ParseError", ["DOCTYPE", "", null, null, false]]}, + +{"description":"<!DOCTYPE ?", +"input":"<!DOCTYPE ?", +"output":["ParseError", ["DOCTYPE", "?", null, null, false]]}, + +{"description":"<!DOCTYPE @", +"input":"<!DOCTYPE @", +"output":["ParseError", ["DOCTYPE", "@", null, null, false]]}, + +{"description":"<!DOCTYPE A", +"input":"<!DOCTYPE A", +"output":["ParseError", ["DOCTYPE", "a", null, null, false]]}, + +{"description":"<!DOCTYPE B", +"input":"<!DOCTYPE B", +"output":["ParseError", ["DOCTYPE", "b", null, null, false]]}, + +{"description":"<!DOCTYPE Y", +"input":"<!DOCTYPE Y", +"output":["ParseError", ["DOCTYPE", "y", null, null, false]]}, + +{"description":"<!DOCTYPE Z", +"input":"<!DOCTYPE Z", +"output":["ParseError", ["DOCTYPE", "z", null, null, false]]}, + +{"description":"<!DOCTYPE [", +"input":"<!DOCTYPE [", +"output":["ParseError", ["DOCTYPE", "[", null, null, false]]}, + +{"description":"<!DOCTYPE `", +"input":"<!DOCTYPE `", +"output":["ParseError", ["DOCTYPE", "`", null, null, false]]}, + +{"description":"<!DOCTYPE a", +"input":"<!DOCTYPE a", +"output":["ParseError", ["DOCTYPE", "a", null, null, false]]}, + +{"description":"<!DOCTYPE a\\u0000", +"input":"<!DOCTYPE a\u0000", +"output":["ParseError", "ParseError", ["DOCTYPE", "a\uFFFD", null, null, false]]}, + +{"description":"<!DOCTYPE a\\u0008", +"input":"<!DOCTYPE a\u0008", +"output":["ParseError", "ParseError", ["DOCTYPE", "a\u0008", null, null, false]]}, + +{"description":"<!DOCTYPE a\\u0009", +"input":"<!DOCTYPE a\u0009", +"output":["ParseError", ["DOCTYPE", "a", null, null, false]]}, + +{"description":"<!DOCTYPE a\\u000A", +"input":"<!DOCTYPE a\u000A", +"output":["ParseError", ["DOCTYPE", "a", null, null, false]]}, + +{"description":"<!DOCTYPE a\\u000B", +"input":"<!DOCTYPE a\u000B", +"output":["ParseError", "ParseError", ["DOCTYPE", "a\u000B", null, null, false]]}, + +{"description":"<!DOCTYPE a\\u000C", +"input":"<!DOCTYPE a\u000C", +"output":["ParseError", ["DOCTYPE", "a", null, null, false]]}, + +{"description":"<!DOCTYPE a\\u000D", +"input":"<!DOCTYPE a\u000D", +"output":["ParseError", ["DOCTYPE", "a", null, null, false]]}, + +{"description":"<!DOCTYPE a\\u001F", +"input":"<!DOCTYPE a\u001F", +"output":["ParseError", "ParseError", ["DOCTYPE", "a\u001F", null, null, false]]}, + +{"description":"<!DOCTYPE a ", +"input":"<!DOCTYPE a ", +"output":["ParseError", ["DOCTYPE", "a", null, null, false]]}, + +{"description":"<!DOCTYPE a \\u0000", +"input":"<!DOCTYPE a \u0000", +"output":["ParseError", ["DOCTYPE", "a", null, null, false]]}, + +{"description":"<!DOCTYPE a \\u0008", +"input":"<!DOCTYPE a \u0008", +"output":["ParseError", "ParseError", ["DOCTYPE", "a", null, null, false]]}, + +{"description":"<!DOCTYPE a \\u0009", +"input":"<!DOCTYPE a \u0009", +"output":["ParseError", ["DOCTYPE", "a", null, null, false]]}, + +{"description":"<!DOCTYPE a \\u000A", +"input":"<!DOCTYPE a \u000A", +"output":["ParseError", ["DOCTYPE", "a", null, null, false]]}, + +{"description":"<!DOCTYPE a \\u000B", +"input":"<!DOCTYPE a \u000B", +"output":["ParseError", "ParseError", ["DOCTYPE", "a", null, null, false]]}, + +{"description":"<!DOCTYPE a \\u000C", +"input":"<!DOCTYPE a \u000C", +"output":["ParseError", ["DOCTYPE", "a", null, null, false]]}, + +{"description":"<!DOCTYPE a \\u000D", +"input":"<!DOCTYPE a \u000D", +"output":["ParseError", ["DOCTYPE", "a", null, null, false]]}, + +{"description":"<!DOCTYPE a \\u001F", +"input":"<!DOCTYPE a \u001F", +"output":["ParseError", "ParseError", ["DOCTYPE", "a", null, null, false]]}, + +{"description":"<!DOCTYPE a ", +"input":"<!DOCTYPE a ", +"output":["ParseError", ["DOCTYPE", "a", null, null, false]]}, + +{"description":"<!DOCTYPE a !", +"input":"<!DOCTYPE a !", +"output":["ParseError", ["DOCTYPE", "a", null, null, false]]}, + +{"description":"<!DOCTYPE a \"", +"input":"<!DOCTYPE a \"", +"output":["ParseError", ["DOCTYPE", "a", null, null, false]]}, + +{"description":"<!DOCTYPE a &", +"input":"<!DOCTYPE a &", +"output":["ParseError", ["DOCTYPE", "a", null, null, false]]}, + +{"description":"<!DOCTYPE a '", +"input":"<!DOCTYPE a '", +"output":["ParseError", ["DOCTYPE", "a", null, null, false]]}, + +{"description":"<!DOCTYPE a -", +"input":"<!DOCTYPE a -", +"output":["ParseError", ["DOCTYPE", "a", null, null, false]]}, + +{"description":"<!DOCTYPE a /", +"input":"<!DOCTYPE a /", +"output":["ParseError", ["DOCTYPE", "a", null, null, false]]}, + +{"description":"<!DOCTYPE a 0", +"input":"<!DOCTYPE a 0", +"output":["ParseError", ["DOCTYPE", "a", null, null, false]]}, + +{"description":"<!DOCTYPE a 1", +"input":"<!DOCTYPE a 1", +"output":["ParseError", ["DOCTYPE", "a", null, null, false]]}, + +{"description":"<!DOCTYPE a 9", +"input":"<!DOCTYPE a 9", +"output":["ParseError", ["DOCTYPE", "a", null, null, false]]}, + +{"description":"<!DOCTYPE a <", +"input":"<!DOCTYPE a <", +"output":["ParseError", ["DOCTYPE", "a", null, null, false]]}, + +{"description":"<!DOCTYPE a =", +"input":"<!DOCTYPE a =", +"output":["ParseError", ["DOCTYPE", "a", null, null, false]]}, + +{"description":"<!DOCTYPE a >", +"input":"<!DOCTYPE a >", +"output":[["DOCTYPE", "a", null, null, true]]}, + +{"description":"<!DOCTYPE a ?", +"input":"<!DOCTYPE a ?", +"output":["ParseError", ["DOCTYPE", "a", null, null, false]]}, + +{"description":"<!DOCTYPE a @", +"input":"<!DOCTYPE a @", +"output":["ParseError", ["DOCTYPE", "a", null, null, false]]}, + +{"description":"<!DOCTYPE a A", +"input":"<!DOCTYPE a A", +"output":["ParseError", ["DOCTYPE", "a", null, null, false]]}, + +{"description":"<!DOCTYPE a B", +"input":"<!DOCTYPE a B", +"output":["ParseError", ["DOCTYPE", "a", null, null, false]]}, + +{"description":"<!DOCTYPE a PUBLIC", +"input":"<!DOCTYPE a PUBLIC", +"output":["ParseError", ["DOCTYPE", "a", null, null, false]]}, + +{"description":"<!DOCTYPE a PUBLIC\\u0000", +"input":"<!DOCTYPE a PUBLIC\u0000", +"output":["ParseError", ["DOCTYPE", "a", null, null, false]]}, + +{"description":"<!DOCTYPE a PUBLIC\\u0008", +"input":"<!DOCTYPE a PUBLIC\u0008", +"output":["ParseError", "ParseError", ["DOCTYPE", "a", null, null, false]]}, + +{"description":"<!DOCTYPE a PUBLIC\\u0009", +"input":"<!DOCTYPE a PUBLIC\u0009", +"output":["ParseError", ["DOCTYPE", "a", null, null, false]]}, + +{"description":"<!DOCTYPE a PUBLIC\\u000A", +"input":"<!DOCTYPE a PUBLIC\u000A", +"output":["ParseError", ["DOCTYPE", "a", null, null, false]]}, + +{"description":"<!DOCTYPE a PUBLIC\\u000B", +"input":"<!DOCTYPE a PUBLIC\u000B", +"output":["ParseError", "ParseError", ["DOCTYPE", "a", null, null, false]]}, + +{"description":"<!DOCTYPE a PUBLIC\\u000C", +"input":"<!DOCTYPE a PUBLIC\u000C", +"output":["ParseError", ["DOCTYPE", "a", null, null, false]]}, + +{"description":"<!DOCTYPE a PUBLIC\\u000D", +"input":"<!DOCTYPE a PUBLIC\u000D", +"output":["ParseError", ["DOCTYPE", "a", null, null, false]]}, + +{"description":"<!DOCTYPE a PUBLIC\\u001F", +"input":"<!DOCTYPE a PUBLIC\u001F", +"output":["ParseError", "ParseError", ["DOCTYPE", "a", null, null, false]]}, + +{"description":"<!DOCTYPE a PUBLIC ", +"input":"<!DOCTYPE a PUBLIC ", +"output":["ParseError", ["DOCTYPE", "a", null, null, false]]}, + +{"description":"<!DOCTYPE a PUBLIC!", +"input":"<!DOCTYPE a PUBLIC!", +"output":["ParseError", ["DOCTYPE", "a", null, null, false]]}, + +{"description":"<!DOCTYPE a PUBLIC\"", +"input":"<!DOCTYPE a PUBLIC\"", +"output":["ParseError", "ParseError", ["DOCTYPE", "a", "", null, false]]}, + +{"description":"<!DOCTYPE a PUBLIC\"\\u0000", +"input":"<!DOCTYPE a PUBLIC\"\u0000", +"output":["ParseError", "ParseError", "ParseError", ["DOCTYPE", "a", "\uFFFD", null, false]]}, + +{"description":"<!DOCTYPE a PUBLIC\"\\u0009", +"input":"<!DOCTYPE a PUBLIC\"\u0009", +"output":["ParseError", "ParseError", ["DOCTYPE", "a", "\u0009", null, false]]}, + +{"description":"<!DOCTYPE a PUBLIC\"\\u000A", +"input":"<!DOCTYPE a PUBLIC\"\u000A", +"output":["ParseError", "ParseError", ["DOCTYPE", "a", "\u000A", null, false]]}, + +{"description":"<!DOCTYPE a PUBLIC\"\\u000B", +"input":"<!DOCTYPE a PUBLIC\"\u000B", +"output":["ParseError", "ParseError", "ParseError", ["DOCTYPE", "a", "\u000B", null, false]]}, + +{"description":"<!DOCTYPE a PUBLIC\"\\u000C", +"input":"<!DOCTYPE a PUBLIC\"\u000C", +"output":["ParseError", "ParseError", ["DOCTYPE", "a", "\u000C", null, false]]}, + +{"description":"<!DOCTYPE a PUBLIC\" ", +"input":"<!DOCTYPE a PUBLIC\" ", +"output":["ParseError", "ParseError", ["DOCTYPE", "a", " ", null, false]]}, + +{"description":"<!DOCTYPE a PUBLIC\"!", +"input":"<!DOCTYPE a PUBLIC\"!", +"output":["ParseError", "ParseError", ["DOCTYPE", "a", "!", null, false]]}, + +{"description":"<!DOCTYPE a PUBLIC\"\"", +"input":"<!DOCTYPE a PUBLIC\"\"", +"output":["ParseError", "ParseError", ["DOCTYPE", "a", "", null, false]]}, + +{"description":"<!DOCTYPE a PUBLIC\"#", +"input":"<!DOCTYPE a PUBLIC\"#", +"output":["ParseError", "ParseError", ["DOCTYPE", "a", "#", null, false]]}, + +{"description":"<!DOCTYPE a PUBLIC\"&", +"input":"<!DOCTYPE a PUBLIC\"&", +"output":["ParseError", "ParseError", ["DOCTYPE", "a", "&", null, false]]}, + +{"description":"<!DOCTYPE a PUBLIC\"'", +"input":"<!DOCTYPE a PUBLIC\"'", +"output":["ParseError", "ParseError", ["DOCTYPE", "a", "'", null, false]]}, + +{"description":"<!DOCTYPE a PUBLIC\"-", +"input":"<!DOCTYPE a PUBLIC\"-", +"output":["ParseError", "ParseError", ["DOCTYPE", "a", "-", null, false]]}, + +{"description":"<!DOCTYPE a PUBLIC\"/", +"input":"<!DOCTYPE a PUBLIC\"/", +"output":["ParseError", "ParseError", ["DOCTYPE", "a", "/", null, false]]}, + +{"description":"<!DOCTYPE a PUBLIC\"0", +"input":"<!DOCTYPE a PUBLIC\"0", +"output":["ParseError", "ParseError", ["DOCTYPE", "a", "0", null, false]]}, + +{"description":"<!DOCTYPE a PUBLIC\"1", +"input":"<!DOCTYPE a PUBLIC\"1", +"output":["ParseError", "ParseError", ["DOCTYPE", "a", "1", null, false]]}, + +{"description":"<!DOCTYPE a PUBLIC\"9", +"input":"<!DOCTYPE a PUBLIC\"9", +"output":["ParseError", "ParseError", ["DOCTYPE", "a", "9", null, false]]}, + +{"description":"<!DOCTYPE a PUBLIC\"<", +"input":"<!DOCTYPE a PUBLIC\"<", +"output":["ParseError", "ParseError", ["DOCTYPE", "a", "<", null, false]]}, + +{"description":"<!DOCTYPE a PUBLIC\"=", +"input":"<!DOCTYPE a PUBLIC\"=", +"output":["ParseError", "ParseError", ["DOCTYPE", "a", "=", null, false]]}, + +{"description":"<!DOCTYPE a PUBLIC\">", +"input":"<!DOCTYPE a PUBLIC\">", +"output":["ParseError", "ParseError", ["DOCTYPE", "a", "", null, false]]}, + +{"description":"<!DOCTYPE a PUBLIC\"?", +"input":"<!DOCTYPE a PUBLIC\"?", +"output":["ParseError", "ParseError", ["DOCTYPE", "a", "?", null, false]]}, + +{"description":"<!DOCTYPE a PUBLIC\"@", +"input":"<!DOCTYPE a PUBLIC\"@", +"output":["ParseError", "ParseError", ["DOCTYPE", "a", "@", null, false]]}, + +{"description":"<!DOCTYPE a PUBLIC\"A", +"input":"<!DOCTYPE a PUBLIC\"A", +"output":["ParseError", "ParseError", ["DOCTYPE", "a", "A", null, false]]}, + +{"description":"<!DOCTYPE a PUBLIC\"B", +"input":"<!DOCTYPE a PUBLIC\"B", +"output":["ParseError", "ParseError", ["DOCTYPE", "a", "B", null, false]]}, + +{"description":"<!DOCTYPE a PUBLIC\"Y", +"input":"<!DOCTYPE a PUBLIC\"Y", +"output":["ParseError", "ParseError", ["DOCTYPE", "a", "Y", null, false]]}, + +{"description":"<!DOCTYPE a PUBLIC\"Z", +"input":"<!DOCTYPE a PUBLIC\"Z", +"output":["ParseError", "ParseError", ["DOCTYPE", "a", "Z", null, false]]}, + +{"description":"<!DOCTYPE a PUBLIC\"`", +"input":"<!DOCTYPE a PUBLIC\"`", +"output":["ParseError", "ParseError", ["DOCTYPE", "a", "`", null, false]]}, + +{"description":"<!DOCTYPE a PUBLIC\"a", +"input":"<!DOCTYPE a PUBLIC\"a", +"output":["ParseError", "ParseError", ["DOCTYPE", "a", "a", null, false]]}, + +{"description":"<!DOCTYPE a PUBLIC\"b", +"input":"<!DOCTYPE a PUBLIC\"b", +"output":["ParseError", "ParseError", ["DOCTYPE", "a", "b", null, false]]}, + +{"description":"<!DOCTYPE a PUBLIC\"y", +"input":"<!DOCTYPE a PUBLIC\"y", +"output":["ParseError", "ParseError", ["DOCTYPE", "a", "y", null, false]]}, + +{"description":"<!DOCTYPE a PUBLIC\"z", +"input":"<!DOCTYPE a PUBLIC\"z", +"output":["ParseError", "ParseError", ["DOCTYPE", "a", "z", null, false]]}, + +{"description":"<!DOCTYPE a PUBLIC\"{", +"input":"<!DOCTYPE a PUBLIC\"{", +"output":["ParseError", "ParseError", ["DOCTYPE", "a", "{", null, false]]}, + +{"description":"<!DOCTYPE a PUBLIC\"\\uDBC0\\uDC00", +"input":"<!DOCTYPE a PUBLIC\"\uDBC0\uDC00", +"output":["ParseError", "ParseError", ["DOCTYPE", "a", "\uDBC0\uDC00", null, false]]}, + +{"description":"<!DOCTYPE a PUBLIC#", +"input":"<!DOCTYPE a PUBLIC#", +"output":["ParseError", ["DOCTYPE", "a", null, null, false]]}, + +{"description":"<!DOCTYPE a PUBLIC&", +"input":"<!DOCTYPE a PUBLIC&", +"output":["ParseError", ["DOCTYPE", "a", null, null, false]]}, + +{"description":"<!DOCTYPE a PUBLIC'", +"input":"<!DOCTYPE a PUBLIC'", +"output":["ParseError", "ParseError", ["DOCTYPE", "a", "", null, false]]}, + +{"description":"<!DOCTYPE a PUBLIC'\\u0000", +"input":"<!DOCTYPE a PUBLIC'\u0000", +"output":["ParseError", "ParseError", "ParseError", ["DOCTYPE", "a", "\uFFFD", null, false]]}, + +{"description":"<!DOCTYPE a PUBLIC'\\u0009", +"input":"<!DOCTYPE a PUBLIC'\u0009", +"output":["ParseError", "ParseError", ["DOCTYPE", "a", "\u0009", null, false]]}, + +{"description":"<!DOCTYPE a PUBLIC'\\u000A", +"input":"<!DOCTYPE a PUBLIC'\u000A", +"output":["ParseError", "ParseError", ["DOCTYPE", "a", "\u000A", null, false]]}, + +{"description":"<!DOCTYPE a PUBLIC'\\u000B", +"input":"<!DOCTYPE a PUBLIC'\u000B", +"output":["ParseError", "ParseError", "ParseError", ["DOCTYPE", "a", "\u000B", null, false]]}, + +{"description":"<!DOCTYPE a PUBLIC'\\u000C", +"input":"<!DOCTYPE a PUBLIC'\u000C", +"output":["ParseError", "ParseError", ["DOCTYPE", "a", "\u000C", null, false]]}, + +{"description":"<!DOCTYPE a PUBLIC' ", +"input":"<!DOCTYPE a PUBLIC' ", +"output":["ParseError", "ParseError", ["DOCTYPE", "a", " ", null, false]]}, + +{"description":"<!DOCTYPE a PUBLIC'!", +"input":"<!DOCTYPE a PUBLIC'!", +"output":["ParseError", "ParseError", ["DOCTYPE", "a", "!", null, false]]}, + +{"description":"<!DOCTYPE a PUBLIC'\"", +"input":"<!DOCTYPE a PUBLIC'\"", +"output":["ParseError", "ParseError", ["DOCTYPE", "a", "\"", null, false]]}, + +{"description":"<!DOCTYPE a PUBLIC'&", +"input":"<!DOCTYPE a PUBLIC'&", +"output":["ParseError", "ParseError", ["DOCTYPE", "a", "&", null, false]]}, + +{"description":"<!DOCTYPE a PUBLIC''", +"input":"<!DOCTYPE a PUBLIC''", +"output":["ParseError", "ParseError", ["DOCTYPE", "a", "", null, false]]}, + +{"description":"<!DOCTYPE a PUBLIC''\\u0000", +"input":"<!DOCTYPE a PUBLIC''\u0000", +"output":["ParseError", "ParseError", ["DOCTYPE", "a", "", null, false]]}, + +{"description":"<!DOCTYPE a PUBLIC''\\u0008", +"input":"<!DOCTYPE a PUBLIC''\u0008", +"output":["ParseError", "ParseError", "ParseError", ["DOCTYPE", "a", "", null, false]]}, + +{"description":"<!DOCTYPE a PUBLIC''\\u0009", +"input":"<!DOCTYPE a PUBLIC''\u0009", +"output":["ParseError", "ParseError", ["DOCTYPE", "a", "", null, false]]}, + +{"description":"<!DOCTYPE a PUBLIC''\\u000A", +"input":"<!DOCTYPE a PUBLIC''\u000A", +"output":["ParseError", "ParseError", ["DOCTYPE", "a", "", null, false]]}, + +{"description":"<!DOCTYPE a PUBLIC''\\u000B", +"input":"<!DOCTYPE a PUBLIC''\u000B", +"output":["ParseError", "ParseError", "ParseError", ["DOCTYPE", "a", "", null, false]]}, + +{"description":"<!DOCTYPE a PUBLIC''\\u000C", +"input":"<!DOCTYPE a PUBLIC''\u000C", +"output":["ParseError", "ParseError", ["DOCTYPE", "a", "", null, false]]}, + +{"description":"<!DOCTYPE a PUBLIC''\\u000D", +"input":"<!DOCTYPE a PUBLIC''\u000D", +"output":["ParseError", "ParseError", ["DOCTYPE", "a", "", null, false]]}, + +{"description":"<!DOCTYPE a PUBLIC''\\u001F", +"input":"<!DOCTYPE a PUBLIC''\u001F", +"output":["ParseError", "ParseError", "ParseError", ["DOCTYPE", "a", "", null, false]]}, + +{"description":"<!DOCTYPE a PUBLIC'' ", +"input":"<!DOCTYPE a PUBLIC'' ", +"output":["ParseError", "ParseError", ["DOCTYPE", "a", "", null, false]]}, + +{"description":"<!DOCTYPE a PUBLIC''!", +"input":"<!DOCTYPE a PUBLIC''!", +"output":["ParseError", "ParseError", ["DOCTYPE", "a", "", null, false]]}, + +{"description":"<!DOCTYPE a PUBLIC''\"", +"input":"<!DOCTYPE a PUBLIC''\"", +"output":["ParseError", "ParseError", "ParseError", ["DOCTYPE", "a", "", "", false]]}, + +{"description":"<!DOCTYPE a PUBLIC''#", +"input":"<!DOCTYPE a PUBLIC''#", +"output":["ParseError", "ParseError", ["DOCTYPE", "a", "", null, false]]}, + +{"description":"<!DOCTYPE a PUBLIC''&", +"input":"<!DOCTYPE a PUBLIC''&", +"output":["ParseError", "ParseError", ["DOCTYPE", "a", "", null, false]]}, + +{"description":"<!DOCTYPE a PUBLIC'''", +"input":"<!DOCTYPE a PUBLIC'''", +"output":["ParseError", "ParseError", "ParseError", ["DOCTYPE", "a", "", "", false]]}, + +{"description":"<!DOCTYPE a PUBLIC''(", +"input":"<!DOCTYPE a PUBLIC''(", +"output":["ParseError", "ParseError", ["DOCTYPE", "a", "", null, false]]}, + +{"description":"<!DOCTYPE a PUBLIC''-", +"input":"<!DOCTYPE a PUBLIC''-", +"output":["ParseError", "ParseError", ["DOCTYPE", "a", "", null, false]]}, + +{"description":"<!DOCTYPE a PUBLIC''/", +"input":"<!DOCTYPE a PUBLIC''/", +"output":["ParseError", "ParseError", ["DOCTYPE", "a", "", null, false]]}, + +{"description":"<!DOCTYPE a PUBLIC''0", +"input":"<!DOCTYPE a PUBLIC''0", +"output":["ParseError", "ParseError", ["DOCTYPE", "a", "", null, false]]}, + +{"description":"<!DOCTYPE a PUBLIC''1", +"input":"<!DOCTYPE a PUBLIC''1", +"output":["ParseError", "ParseError", ["DOCTYPE", "a", "", null, false]]}, + +{"description":"<!DOCTYPE a PUBLIC''9", +"input":"<!DOCTYPE a PUBLIC''9", +"output":["ParseError", "ParseError", ["DOCTYPE", "a", "", null, false]]}, + +{"description":"<!DOCTYPE a PUBLIC''<", +"input":"<!DOCTYPE a PUBLIC''<", +"output":["ParseError", "ParseError", ["DOCTYPE", "a", "", null, false]]}, + +{"description":"<!DOCTYPE a PUBLIC''=", +"input":"<!DOCTYPE a PUBLIC''=", +"output":["ParseError", "ParseError", ["DOCTYPE", "a", "", null, false]]}, + +{"description":"<!DOCTYPE a PUBLIC''>", +"input":"<!DOCTYPE a PUBLIC''>", +"output":["ParseError", ["DOCTYPE", "a", "", null, true]]}, + +{"description":"<!DOCTYPE a PUBLIC''?", +"input":"<!DOCTYPE a PUBLIC''?", +"output":["ParseError", "ParseError", ["DOCTYPE", "a", "", null, false]]}, + +{"description":"<!DOCTYPE a PUBLIC''@", +"input":"<!DOCTYPE a PUBLIC''@", +"output":["ParseError", "ParseError", ["DOCTYPE", "a", "", null, false]]}, + +{"description":"<!DOCTYPE a PUBLIC''A", +"input":"<!DOCTYPE a PUBLIC''A", +"output":["ParseError", "ParseError", ["DOCTYPE", "a", "", null, false]]}, + +{"description":"<!DOCTYPE a PUBLIC''B", +"input":"<!DOCTYPE a PUBLIC''B", +"output":["ParseError", "ParseError", ["DOCTYPE", "a", "", null, false]]}, + +{"description":"<!DOCTYPE a PUBLIC''Y", +"input":"<!DOCTYPE a PUBLIC''Y", +"output":["ParseError", "ParseError", ["DOCTYPE", "a", "", null, false]]}, + +{"description":"<!DOCTYPE a PUBLIC''Z", +"input":"<!DOCTYPE a PUBLIC''Z", +"output":["ParseError", "ParseError", ["DOCTYPE", "a", "", null, false]]}, + +{"description":"<!DOCTYPE a PUBLIC''`", +"input":"<!DOCTYPE a PUBLIC''`", +"output":["ParseError", "ParseError", ["DOCTYPE", "a", "", null, false]]}, + +{"description":"<!DOCTYPE a PUBLIC''a", +"input":"<!DOCTYPE a PUBLIC''a", +"output":["ParseError", "ParseError", ["DOCTYPE", "a", "", null, false]]}, + +{"description":"<!DOCTYPE a PUBLIC''b", +"input":"<!DOCTYPE a PUBLIC''b", +"output":["ParseError", "ParseError", ["DOCTYPE", "a", "", null, false]]}, + +{"description":"<!DOCTYPE a PUBLIC''y", +"input":"<!DOCTYPE a PUBLIC''y", +"output":["ParseError", "ParseError", ["DOCTYPE", "a", "", null, false]]}, + +{"description":"<!DOCTYPE a PUBLIC''z", +"input":"<!DOCTYPE a PUBLIC''z", +"output":["ParseError", "ParseError", ["DOCTYPE", "a", "", null, false]]}, + +{"description":"<!DOCTYPE a PUBLIC''{", +"input":"<!DOCTYPE a PUBLIC''{", +"output":["ParseError", "ParseError", ["DOCTYPE", "a", "", null, false]]}, + +{"description":"<!DOCTYPE a PUBLIC''\\uDBC0\\uDC00", +"input":"<!DOCTYPE a PUBLIC''\uDBC0\uDC00", +"output":["ParseError", "ParseError", ["DOCTYPE", "a", "", null, false]]}, + +{"description":"<!DOCTYPE a PUBLIC'(", +"input":"<!DOCTYPE a PUBLIC'(", +"output":["ParseError", "ParseError", ["DOCTYPE", "a", "(", null, false]]}, + +{"description":"<!DOCTYPE a PUBLIC'-", +"input":"<!DOCTYPE a PUBLIC'-", +"output":["ParseError", "ParseError", ["DOCTYPE", "a", "-", null, false]]}, + +{"description":"<!DOCTYPE a PUBLIC'/", +"input":"<!DOCTYPE a PUBLIC'/", +"output":["ParseError", "ParseError", ["DOCTYPE", "a", "/", null, false]]}, + +{"description":"<!DOCTYPE a PUBLIC'0", +"input":"<!DOCTYPE a PUBLIC'0", +"output":["ParseError", "ParseError", ["DOCTYPE", "a", "0", null, false]]}, + +{"description":"<!DOCTYPE a PUBLIC'1", +"input":"<!DOCTYPE a PUBLIC'1", +"output":["ParseError", "ParseError", ["DOCTYPE", "a", "1", null, false]]}, + +{"description":"<!DOCTYPE a PUBLIC'9", +"input":"<!DOCTYPE a PUBLIC'9", +"output":["ParseError", "ParseError", ["DOCTYPE", "a", "9", null, false]]}, + +{"description":"<!DOCTYPE a PUBLIC'<", +"input":"<!DOCTYPE a PUBLIC'<", +"output":["ParseError", "ParseError", ["DOCTYPE", "a", "<", null, false]]}, + +{"description":"<!DOCTYPE a PUBLIC'=", +"input":"<!DOCTYPE a PUBLIC'=", +"output":["ParseError", "ParseError", ["DOCTYPE", "a", "=", null, false]]}, + +{"description":"<!DOCTYPE a PUBLIC'>", +"input":"<!DOCTYPE a PUBLIC'>", +"output":["ParseError", "ParseError", ["DOCTYPE", "a", "", null, false]]}, + +{"description":"<!DOCTYPE a PUBLIC'?", +"input":"<!DOCTYPE a PUBLIC'?", +"output":["ParseError", "ParseError", ["DOCTYPE", "a", "?", null, false]]}, + +{"description":"<!DOCTYPE a PUBLIC'@", +"input":"<!DOCTYPE a PUBLIC'@", +"output":["ParseError", "ParseError", ["DOCTYPE", "a", "@", null, false]]}, + +{"description":"<!DOCTYPE a PUBLIC'A", +"input":"<!DOCTYPE a PUBLIC'A", +"output":["ParseError", "ParseError", ["DOCTYPE", "a", "A", null, false]]}, + +{"description":"<!DOCTYPE a PUBLIC'B", +"input":"<!DOCTYPE a PUBLIC'B", +"output":["ParseError", "ParseError", ["DOCTYPE", "a", "B", null, false]]}, + +{"description":"<!DOCTYPE a PUBLIC'Y", +"input":"<!DOCTYPE a PUBLIC'Y", +"output":["ParseError", "ParseError", ["DOCTYPE", "a", "Y", null, false]]}, + +{"description":"<!DOCTYPE a PUBLIC'Z", +"input":"<!DOCTYPE a PUBLIC'Z", +"output":["ParseError", "ParseError", ["DOCTYPE", "a", "Z", null, false]]}, + +{"description":"<!DOCTYPE a PUBLIC'`", +"input":"<!DOCTYPE a PUBLIC'`", +"output":["ParseError", "ParseError", ["DOCTYPE", "a", "`", null, false]]}, + +{"description":"<!DOCTYPE a PUBLIC'a", +"input":"<!DOCTYPE a PUBLIC'a", +"output":["ParseError", "ParseError", ["DOCTYPE", "a", "a", null, false]]}, + +{"description":"<!DOCTYPE a PUBLIC'b", +"input":"<!DOCTYPE a PUBLIC'b", +"output":["ParseError", "ParseError", ["DOCTYPE", "a", "b", null, false]]}, + +{"description":"<!DOCTYPE a PUBLIC'y", +"input":"<!DOCTYPE a PUBLIC'y", +"output":["ParseError", "ParseError", ["DOCTYPE", "a", "y", null, false]]}, + +{"description":"<!DOCTYPE a PUBLIC'z", +"input":"<!DOCTYPE a PUBLIC'z", +"output":["ParseError", "ParseError", ["DOCTYPE", "a", "z", null, false]]}, + +{"description":"<!DOCTYPE a PUBLIC'{", +"input":"<!DOCTYPE a PUBLIC'{", +"output":["ParseError", "ParseError", ["DOCTYPE", "a", "{", null, false]]}, + +{"description":"<!DOCTYPE a PUBLIC'\\uDBC0\\uDC00", +"input":"<!DOCTYPE a PUBLIC'\uDBC0\uDC00", +"output":["ParseError", "ParseError", ["DOCTYPE", "a", "\uDBC0\uDC00", null, false]]}, + +{"description":"<!DOCTYPE a PUBLIC(", +"input":"<!DOCTYPE a PUBLIC(", +"output":["ParseError", ["DOCTYPE", "a", null, null, false]]}, + +{"description":"<!DOCTYPE a PUBLIC-", +"input":"<!DOCTYPE a PUBLIC-", +"output":["ParseError", ["DOCTYPE", "a", null, null, false]]}, + +{"description":"<!DOCTYPE a PUBLIC/", +"input":"<!DOCTYPE a PUBLIC/", +"output":["ParseError", ["DOCTYPE", "a", null, null, false]]}, + +{"description":"<!DOCTYPE a PUBLIC0", +"input":"<!DOCTYPE a PUBLIC0", +"output":["ParseError", ["DOCTYPE", "a", null, null, false]]}, + +{"description":"<!DOCTYPE a PUBLIC1", +"input":"<!DOCTYPE a PUBLIC1", +"output":["ParseError", ["DOCTYPE", "a", null, null, false]]}, + +{"description":"<!DOCTYPE a PUBLIC9", +"input":"<!DOCTYPE a PUBLIC9", +"output":["ParseError", ["DOCTYPE", "a", null, null, false]]}, + +{"description":"<!DOCTYPE a PUBLIC<", +"input":"<!DOCTYPE a PUBLIC<", +"output":["ParseError", ["DOCTYPE", "a", null, null, false]]}, + +{"description":"<!DOCTYPE a PUBLIC=", +"input":"<!DOCTYPE a PUBLIC=", +"output":["ParseError", ["DOCTYPE", "a", null, null, false]]}, + +{"description":"<!DOCTYPE a PUBLIC>", +"input":"<!DOCTYPE a PUBLIC>", +"output":["ParseError", ["DOCTYPE", "a", null, null, false]]}, + +{"description":"<!DOCTYPE a PUBLIC?", +"input":"<!DOCTYPE a PUBLIC?", +"output":["ParseError", ["DOCTYPE", "a", null, null, false]]}, + +{"description":"<!DOCTYPE a PUBLIC@", +"input":"<!DOCTYPE a PUBLIC@", +"output":["ParseError", ["DOCTYPE", "a", null, null, false]]}, + +{"description":"<!DOCTYPE a PUBLICA", +"input":"<!DOCTYPE a PUBLICA", +"output":["ParseError", ["DOCTYPE", "a", null, null, false]]}, + +{"description":"<!DOCTYPE a PUBLICB", +"input":"<!DOCTYPE a PUBLICB", +"output":["ParseError", ["DOCTYPE", "a", null, null, false]]}, + +{"description":"<!DOCTYPE a PUBLICY", +"input":"<!DOCTYPE a PUBLICY", +"output":["ParseError", ["DOCTYPE", "a", null, null, false]]}, + +{"description":"<!DOCTYPE a PUBLICZ", +"input":"<!DOCTYPE a PUBLICZ", +"output":["ParseError", ["DOCTYPE", "a", null, null, false]]}, + +{"description":"<!DOCTYPE a PUBLIC`", +"input":"<!DOCTYPE a PUBLIC`", +"output":["ParseError", ["DOCTYPE", "a", null, null, false]]}, + +{"description":"<!DOCTYPE a PUBLICa", +"input":"<!DOCTYPE a PUBLICa", +"output":["ParseError", ["DOCTYPE", "a", null, null, false]]}, + +{"description":"<!DOCTYPE a PUBLICb", +"input":"<!DOCTYPE a PUBLICb", +"output":["ParseError", ["DOCTYPE", "a", null, null, false]]}, + +{"description":"<!DOCTYPE a PUBLICy", +"input":"<!DOCTYPE a PUBLICy", +"output":["ParseError", ["DOCTYPE", "a", null, null, false]]}, + +{"description":"<!DOCTYPE a PUBLICz", +"input":"<!DOCTYPE a PUBLICz", +"output":["ParseError", ["DOCTYPE", "a", null, null, false]]}, + +{"description":"<!DOCTYPE a PUBLIC{", +"input":"<!DOCTYPE a PUBLIC{", +"output":["ParseError", ["DOCTYPE", "a", null, null, false]]}, + +{"description":"<!DOCTYPE a PUBLIC\\uDBC0\\uDC00", +"input":"<!DOCTYPE a PUBLIC\uDBC0\uDC00", +"output":["ParseError", ["DOCTYPE", "a", null, null, false]]}, + +{"description":"<!DOCTYPE a SYSTEM", +"input":"<!DOCTYPE a SYSTEM", +"output":["ParseError", ["DOCTYPE", "a", null, null, false]]}, + +{"description":"<!DOCTYPE a SYSTEM\\u0000", +"input":"<!DOCTYPE a SYSTEM\u0000", +"output":["ParseError", ["DOCTYPE", "a", null, null, false]]}, + +{"description":"<!DOCTYPE a SYSTEM\\u0008", +"input":"<!DOCTYPE a SYSTEM\u0008", +"output":["ParseError", "ParseError", ["DOCTYPE", "a", null, null, false]]}, + +{"description":"<!DOCTYPE a SYSTEM\\u0009", +"input":"<!DOCTYPE a SYSTEM\u0009", +"output":["ParseError", ["DOCTYPE", "a", null, null, false]]}, + +{"description":"<!DOCTYPE a SYSTEM\\u000A", +"input":"<!DOCTYPE a SYSTEM\u000A", +"output":["ParseError", ["DOCTYPE", "a", null, null, false]]}, + +{"description":"<!DOCTYPE a SYSTEM\\u000B", +"input":"<!DOCTYPE a SYSTEM\u000B", +"output":["ParseError", "ParseError", ["DOCTYPE", "a", null, null, false]]}, + +{"description":"<!DOCTYPE a SYSTEM\\u000C", +"input":"<!DOCTYPE a SYSTEM\u000C", +"output":["ParseError", ["DOCTYPE", "a", null, null, false]]}, + +{"description":"<!DOCTYPE a SYSTEM\\u000D", +"input":"<!DOCTYPE a SYSTEM\u000D", +"output":["ParseError", ["DOCTYPE", "a", null, null, false]]}, + +{"description":"<!DOCTYPE a SYSTEM\\u001F", +"input":"<!DOCTYPE a SYSTEM\u001F", +"output":["ParseError", "ParseError", ["DOCTYPE", "a", null, null, false]]}, + +{"description":"<!DOCTYPE a SYSTEM ", +"input":"<!DOCTYPE a SYSTEM ", +"output":["ParseError", ["DOCTYPE", "a", null, null, false]]}, + +{"description":"<!DOCTYPE a SYSTEM!", +"input":"<!DOCTYPE a SYSTEM!", +"output":["ParseError", ["DOCTYPE", "a", null, null, false]]}, + +{"description":"<!DOCTYPE a SYSTEM\"", +"input":"<!DOCTYPE a SYSTEM\"", +"output":["ParseError", "ParseError", ["DOCTYPE", "a", null, "", false]]}, + +{"description":"<!DOCTYPE a SYSTEM\"\\u0000", +"input":"<!DOCTYPE a SYSTEM\"\u0000", +"output":["ParseError", "ParseError", "ParseError", ["DOCTYPE", "a", null, "\uFFFD", false]]}, + +{"description":"<!DOCTYPE a SYSTEM\"\\u0009", +"input":"<!DOCTYPE a SYSTEM\"\u0009", +"output":["ParseError", "ParseError", ["DOCTYPE", "a", null, "\u0009", false]]}, + +{"description":"<!DOCTYPE a SYSTEM\"\\u000A", +"input":"<!DOCTYPE a SYSTEM\"\u000A", +"output":["ParseError", "ParseError", ["DOCTYPE", "a", null, "\u000A", false]]}, + +{"description":"<!DOCTYPE a SYSTEM\"\\u000B", +"input":"<!DOCTYPE a SYSTEM\"\u000B", +"output":["ParseError", "ParseError", "ParseError", ["DOCTYPE", "a", null, "\u000B", false]]}, + +{"description":"<!DOCTYPE a SYSTEM\"\\u000C", +"input":"<!DOCTYPE a SYSTEM\"\u000C", +"output":["ParseError", "ParseError", ["DOCTYPE", "a", null, "\u000C", false]]}, + +{"description":"<!DOCTYPE a SYSTEM\" ", +"input":"<!DOCTYPE a SYSTEM\" ", +"output":["ParseError", "ParseError", ["DOCTYPE", "a", null, " ", false]]}, + +{"description":"<!DOCTYPE a SYSTEM\"!", +"input":"<!DOCTYPE a SYSTEM\"!", +"output":["ParseError", "ParseError", ["DOCTYPE", "a", null, "!", false]]}, + +{"description":"<!DOCTYPE a SYSTEM\"\"", +"input":"<!DOCTYPE a SYSTEM\"\"", +"output":["ParseError", "ParseError", ["DOCTYPE", "a", null, "", false]]}, + +{"description":"<!DOCTYPE a SYSTEM\"#", +"input":"<!DOCTYPE a SYSTEM\"#", +"output":["ParseError", "ParseError", ["DOCTYPE", "a", null, "#", false]]}, + +{"description":"<!DOCTYPE a SYSTEM\"&", +"input":"<!DOCTYPE a SYSTEM\"&", +"output":["ParseError", "ParseError", ["DOCTYPE", "a", null, "&", false]]}, + +{"description":"<!DOCTYPE a SYSTEM\"'", +"input":"<!DOCTYPE a SYSTEM\"'", +"output":["ParseError", "ParseError", ["DOCTYPE", "a", null, "'", false]]}, + +{"description":"<!DOCTYPE a SYSTEM\"-", +"input":"<!DOCTYPE a SYSTEM\"-", +"output":["ParseError", "ParseError", ["DOCTYPE", "a", null, "-", false]]}, + +{"description":"<!DOCTYPE a SYSTEM\"/", +"input":"<!DOCTYPE a SYSTEM\"/", +"output":["ParseError", "ParseError", ["DOCTYPE", "a", null, "/", false]]}, + +{"description":"<!DOCTYPE a SYSTEM\"0", +"input":"<!DOCTYPE a SYSTEM\"0", +"output":["ParseError", "ParseError", ["DOCTYPE", "a", null, "0", false]]}, + +{"description":"<!DOCTYPE a SYSTEM\"1", +"input":"<!DOCTYPE a SYSTEM\"1", +"output":["ParseError", "ParseError", ["DOCTYPE", "a", null, "1", false]]}, + +{"description":"<!DOCTYPE a SYSTEM\"9", +"input":"<!DOCTYPE a SYSTEM\"9", +"output":["ParseError", "ParseError", ["DOCTYPE", "a", null, "9", false]]}, + +{"description":"<!DOCTYPE a SYSTEM\"<", +"input":"<!DOCTYPE a SYSTEM\"<", +"output":["ParseError", "ParseError", ["DOCTYPE", "a", null, "<", false]]}, + +{"description":"<!DOCTYPE a SYSTEM\"=", +"input":"<!DOCTYPE a SYSTEM\"=", +"output":["ParseError", "ParseError", ["DOCTYPE", "a", null, "=", false]]}, + +{"description":"<!DOCTYPE a SYSTEM\">", +"input":"<!DOCTYPE a SYSTEM\">", +"output":["ParseError", "ParseError", ["DOCTYPE", "a", null, "", false]]}, + +{"description":"<!DOCTYPE a SYSTEM\"?", +"input":"<!DOCTYPE a SYSTEM\"?", +"output":["ParseError", "ParseError", ["DOCTYPE", "a", null, "?", false]]}, + +{"description":"<!DOCTYPE a SYSTEM\"@", +"input":"<!DOCTYPE a SYSTEM\"@", +"output":["ParseError", "ParseError", ["DOCTYPE", "a", null, "@", false]]}, + +{"description":"<!DOCTYPE a SYSTEM\"A", +"input":"<!DOCTYPE a SYSTEM\"A", +"output":["ParseError", "ParseError", ["DOCTYPE", "a", null, "A", false]]}, + +{"description":"<!DOCTYPE a SYSTEM\"B", +"input":"<!DOCTYPE a SYSTEM\"B", +"output":["ParseError", "ParseError", ["DOCTYPE", "a", null, "B", false]]}, + +{"description":"<!DOCTYPE a SYSTEM\"Y", +"input":"<!DOCTYPE a SYSTEM\"Y", +"output":["ParseError", "ParseError", ["DOCTYPE", "a", null, "Y", false]]}, + +{"description":"<!DOCTYPE a SYSTEM\"Z", +"input":"<!DOCTYPE a SYSTEM\"Z", +"output":["ParseError", "ParseError", ["DOCTYPE", "a", null, "Z", false]]}, + +{"description":"<!DOCTYPE a SYSTEM\"`", +"input":"<!DOCTYPE a SYSTEM\"`", +"output":["ParseError", "ParseError", ["DOCTYPE", "a", null, "`", false]]}, + +{"description":"<!DOCTYPE a SYSTEM\"a", +"input":"<!DOCTYPE a SYSTEM\"a", +"output":["ParseError", "ParseError", ["DOCTYPE", "a", null, "a", false]]}, + +{"description":"<!DOCTYPE a SYSTEM\"b", +"input":"<!DOCTYPE a SYSTEM\"b", +"output":["ParseError", "ParseError", ["DOCTYPE", "a", null, "b", false]]}, + +{"description":"<!DOCTYPE a SYSTEM\"y", +"input":"<!DOCTYPE a SYSTEM\"y", +"output":["ParseError", "ParseError", ["DOCTYPE", "a", null, "y", false]]}, + +{"description":"<!DOCTYPE a SYSTEM\"z", +"input":"<!DOCTYPE a SYSTEM\"z", +"output":["ParseError", "ParseError", ["DOCTYPE", "a", null, "z", false]]}, + +{"description":"<!DOCTYPE a SYSTEM\"{", +"input":"<!DOCTYPE a SYSTEM\"{", +"output":["ParseError", "ParseError", ["DOCTYPE", "a", null, "{", false]]}, + +{"description":"<!DOCTYPE a SYSTEM\"\\uDBC0\\uDC00", +"input":"<!DOCTYPE a SYSTEM\"\uDBC0\uDC00", +"output":["ParseError", "ParseError", ["DOCTYPE", "a", null, "\uDBC0\uDC00", false]]}, + +{"description":"<!DOCTYPE a SYSTEM#", +"input":"<!DOCTYPE a SYSTEM#", +"output":["ParseError", ["DOCTYPE", "a", null, null, false]]}, + +{"description":"<!DOCTYPE a SYSTEM&", +"input":"<!DOCTYPE a SYSTEM&", +"output":["ParseError", ["DOCTYPE", "a", null, null, false]]}, + +{"description":"<!DOCTYPE a SYSTEM'", +"input":"<!DOCTYPE a SYSTEM'", +"output":["ParseError", "ParseError", ["DOCTYPE", "a", null, "", false]]}, + +{"description":"<!DOCTYPE a SYSTEM'\\u0000", +"input":"<!DOCTYPE a SYSTEM'\u0000", +"output":["ParseError", "ParseError", "ParseError", ["DOCTYPE", "a", null, "\uFFFD", false]]}, + +{"description":"<!DOCTYPE a SYSTEM'\\u0009", +"input":"<!DOCTYPE a SYSTEM'\u0009", +"output":["ParseError", "ParseError", ["DOCTYPE", "a", null, "\u0009", false]]}, + +{"description":"<!DOCTYPE a SYSTEM'\\u000A", +"input":"<!DOCTYPE a SYSTEM'\u000A", +"output":["ParseError", "ParseError", ["DOCTYPE", "a", null, "\u000A", false]]}, + +{"description":"<!DOCTYPE a SYSTEM'\\u000B", +"input":"<!DOCTYPE a SYSTEM'\u000B", +"output":["ParseError", "ParseError", "ParseError", ["DOCTYPE", "a", null, "\u000B", false]]}, + +{"description":"<!DOCTYPE a SYSTEM'\\u000C", +"input":"<!DOCTYPE a SYSTEM'\u000C", +"output":["ParseError", "ParseError", ["DOCTYPE", "a", null, "\u000C", false]]}, + +{"description":"<!DOCTYPE a SYSTEM' ", +"input":"<!DOCTYPE a SYSTEM' ", +"output":["ParseError", "ParseError", ["DOCTYPE", "a", null, " ", false]]}, + +{"description":"<!DOCTYPE a SYSTEM'!", +"input":"<!DOCTYPE a SYSTEM'!", +"output":["ParseError", "ParseError", ["DOCTYPE", "a", null, "!", false]]}, + +{"description":"<!DOCTYPE a SYSTEM'\"", +"input":"<!DOCTYPE a SYSTEM'\"", +"output":["ParseError", "ParseError", ["DOCTYPE", "a", null, "\"", false]]}, + +{"description":"<!DOCTYPE a SYSTEM'&", +"input":"<!DOCTYPE a SYSTEM'&", +"output":["ParseError", "ParseError", ["DOCTYPE", "a", null, "&", false]]}, + +{"description":"<!DOCTYPE a SYSTEM''", +"input":"<!DOCTYPE a SYSTEM''", +"output":["ParseError", "ParseError", ["DOCTYPE", "a", null, "", false]]}, + +{"description":"<!DOCTYPE a SYSTEM''\\u0000", +"input":"<!DOCTYPE a SYSTEM''\u0000", +"output":["ParseError", "ParseError", ["DOCTYPE", "a", null, "", true]]}, + +{"description":"<!DOCTYPE a SYSTEM''\\u0008", +"input":"<!DOCTYPE a SYSTEM''\u0008", +"output":["ParseError", "ParseError", "ParseError", ["DOCTYPE", "a", null, "", true]]}, + +{"description":"<!DOCTYPE a SYSTEM''\\u0009", +"input":"<!DOCTYPE a SYSTEM''\u0009", +"output":["ParseError", "ParseError", ["DOCTYPE", "a", null, "", false]]}, + +{"description":"<!DOCTYPE a SYSTEM''\\u000A", +"input":"<!DOCTYPE a SYSTEM''\u000A", +"output":["ParseError", "ParseError", ["DOCTYPE", "a", null, "", false]]}, + +{"description":"<!DOCTYPE a SYSTEM''\\u000B", +"input":"<!DOCTYPE a SYSTEM''\u000B", +"output":["ParseError", "ParseError", "ParseError", ["DOCTYPE", "a", null, "", true]]}, + +{"description":"<!DOCTYPE a SYSTEM''\\u000C", +"input":"<!DOCTYPE a SYSTEM''\u000C", +"output":["ParseError", "ParseError", ["DOCTYPE", "a", null, "", false]]}, + +{"description":"<!DOCTYPE a SYSTEM''\\u000D", +"input":"<!DOCTYPE a SYSTEM''\u000D", +"output":["ParseError", "ParseError", ["DOCTYPE", "a", null, "", false]]}, + +{"description":"<!DOCTYPE a SYSTEM''\\u001F", +"input":"<!DOCTYPE a SYSTEM''\u001F", +"output":["ParseError", "ParseError", "ParseError", ["DOCTYPE", "a", null, "", true]]}, + +{"description":"<!DOCTYPE a SYSTEM'' ", +"input":"<!DOCTYPE a SYSTEM'' ", +"output":["ParseError", "ParseError", ["DOCTYPE", "a", null, "", false]]}, + +{"description":"<!DOCTYPE a SYSTEM''!", +"input":"<!DOCTYPE a SYSTEM''!", +"output":["ParseError", "ParseError", ["DOCTYPE", "a", null, "", true]]}, + +{"description":"<!DOCTYPE a SYSTEM''\"", +"input":"<!DOCTYPE a SYSTEM''\"", +"output":["ParseError", "ParseError", ["DOCTYPE", "a", null, "", true]]}, + +{"description":"<!DOCTYPE a SYSTEM''&", +"input":"<!DOCTYPE a SYSTEM''&", +"output":["ParseError", "ParseError", ["DOCTYPE", "a", null, "", true]]}, + +{"description":"<!DOCTYPE a SYSTEM'''", +"input":"<!DOCTYPE a SYSTEM'''", +"output":["ParseError", "ParseError", ["DOCTYPE", "a", null, "", true]]}, + +{"description":"<!DOCTYPE a SYSTEM''-", +"input":"<!DOCTYPE a SYSTEM''-", +"output":["ParseError", "ParseError", ["DOCTYPE", "a", null, "", true]]}, + +{"description":"<!DOCTYPE a SYSTEM''/", +"input":"<!DOCTYPE a SYSTEM''/", +"output":["ParseError", "ParseError", ["DOCTYPE", "a", null, "", true]]}, + +{"description":"<!DOCTYPE a SYSTEM''0", +"input":"<!DOCTYPE a SYSTEM''0", +"output":["ParseError", "ParseError", ["DOCTYPE", "a", null, "", true]]}, + +{"description":"<!DOCTYPE a SYSTEM''1", +"input":"<!DOCTYPE a SYSTEM''1", +"output":["ParseError", "ParseError", ["DOCTYPE", "a", null, "", true]]}, + +{"description":"<!DOCTYPE a SYSTEM''9", +"input":"<!DOCTYPE a SYSTEM''9", +"output":["ParseError", "ParseError", ["DOCTYPE", "a", null, "", true]]}, + +{"description":"<!DOCTYPE a SYSTEM''<", +"input":"<!DOCTYPE a SYSTEM''<", +"output":["ParseError", "ParseError", ["DOCTYPE", "a", null, "", true]]}, + +{"description":"<!DOCTYPE a SYSTEM''=", +"input":"<!DOCTYPE a SYSTEM''=", +"output":["ParseError", "ParseError", ["DOCTYPE", "a", null, "", true]]}, + +{"description":"<!DOCTYPE a SYSTEM''>", +"input":"<!DOCTYPE a SYSTEM''>", +"output":["ParseError", ["DOCTYPE", "a", null, "", true]]}, + +{"description":"<!DOCTYPE a SYSTEM''?", +"input":"<!DOCTYPE a SYSTEM''?", +"output":["ParseError", "ParseError", ["DOCTYPE", "a", null, "", true]]}, + +{"description":"<!DOCTYPE a SYSTEM''@", +"input":"<!DOCTYPE a SYSTEM''@", +"output":["ParseError", "ParseError", ["DOCTYPE", "a", null, "", true]]}, + +{"description":"<!DOCTYPE a SYSTEM''A", +"input":"<!DOCTYPE a SYSTEM''A", +"output":["ParseError", "ParseError", ["DOCTYPE", "a", null, "", true]]}, + +{"description":"<!DOCTYPE a SYSTEM''B", +"input":"<!DOCTYPE a SYSTEM''B", +"output":["ParseError", "ParseError", ["DOCTYPE", "a", null, "", true]]}, + +{"description":"<!DOCTYPE a SYSTEM''Y", +"input":"<!DOCTYPE a SYSTEM''Y", +"output":["ParseError", "ParseError", ["DOCTYPE", "a", null, "", true]]}, + +{"description":"<!DOCTYPE a SYSTEM''Z", +"input":"<!DOCTYPE a SYSTEM''Z", +"output":["ParseError", "ParseError", ["DOCTYPE", "a", null, "", true]]}, + +{"description":"<!DOCTYPE a SYSTEM''`", +"input":"<!DOCTYPE a SYSTEM''`", +"output":["ParseError", "ParseError", ["DOCTYPE", "a", null, "", true]]}, + +{"description":"<!DOCTYPE a SYSTEM''a", +"input":"<!DOCTYPE a SYSTEM''a", +"output":["ParseError", "ParseError", ["DOCTYPE", "a", null, "", true]]}, + +{"description":"<!DOCTYPE a SYSTEM''b", +"input":"<!DOCTYPE a SYSTEM''b", +"output":["ParseError", "ParseError", ["DOCTYPE", "a", null, "", true]]}, + +{"description":"<!DOCTYPE a SYSTEM''y", +"input":"<!DOCTYPE a SYSTEM''y", +"output":["ParseError", "ParseError", ["DOCTYPE", "a", null, "", true]]}, + +{"description":"<!DOCTYPE a SYSTEM''z", +"input":"<!DOCTYPE a SYSTEM''z", +"output":["ParseError", "ParseError", ["DOCTYPE", "a", null, "", true]]}, + +{"description":"<!DOCTYPE a SYSTEM''{", +"input":"<!DOCTYPE a SYSTEM''{", +"output":["ParseError", "ParseError", ["DOCTYPE", "a", null, "", true]]}, + +{"description":"<!DOCTYPE a SYSTEM''\\uDBC0\\uDC00", +"input":"<!DOCTYPE a SYSTEM''\uDBC0\uDC00", +"output":["ParseError", "ParseError", ["DOCTYPE", "a", null, "", true]]}, + +{"description":"<!DOCTYPE a SYSTEM'(", +"input":"<!DOCTYPE a SYSTEM'(", +"output":["ParseError", "ParseError", ["DOCTYPE", "a", null, "(", false]]}, + +{"description":"<!DOCTYPE a SYSTEM'-", +"input":"<!DOCTYPE a SYSTEM'-", +"output":["ParseError", "ParseError", ["DOCTYPE", "a", null, "-", false]]}, + +{"description":"<!DOCTYPE a SYSTEM'/", +"input":"<!DOCTYPE a SYSTEM'/", +"output":["ParseError", "ParseError", ["DOCTYPE", "a", null, "/", false]]}, + +{"description":"<!DOCTYPE a SYSTEM'0", +"input":"<!DOCTYPE a SYSTEM'0", +"output":["ParseError", "ParseError", ["DOCTYPE", "a", null, "0", false]]}, + +{"description":"<!DOCTYPE a SYSTEM'1", +"input":"<!DOCTYPE a SYSTEM'1", +"output":["ParseError", "ParseError", ["DOCTYPE", "a", null, "1", false]]}, + +{"description":"<!DOCTYPE a SYSTEM'9", +"input":"<!DOCTYPE a SYSTEM'9", +"output":["ParseError", "ParseError", ["DOCTYPE", "a", null, "9", false]]}, + +{"description":"<!DOCTYPE a SYSTEM'<", +"input":"<!DOCTYPE a SYSTEM'<", +"output":["ParseError", "ParseError", ["DOCTYPE", "a", null, "<", false]]}, + +{"description":"<!DOCTYPE a SYSTEM'=", +"input":"<!DOCTYPE a SYSTEM'=", +"output":["ParseError", "ParseError", ["DOCTYPE", "a", null, "=", false]]}, + +{"description":"<!DOCTYPE a SYSTEM'>", +"input":"<!DOCTYPE a SYSTEM'>", +"output":["ParseError", "ParseError", ["DOCTYPE", "a", null, "", false]]}, + +{"description":"<!DOCTYPE a SYSTEM'?", +"input":"<!DOCTYPE a SYSTEM'?", +"output":["ParseError", "ParseError", ["DOCTYPE", "a", null, "?", false]]}, + +{"description":"<!DOCTYPE a SYSTEM'@", +"input":"<!DOCTYPE a SYSTEM'@", +"output":["ParseError", "ParseError", ["DOCTYPE", "a", null, "@", false]]}, + +{"description":"<!DOCTYPE a SYSTEM'A", +"input":"<!DOCTYPE a SYSTEM'A", +"output":["ParseError", "ParseError", ["DOCTYPE", "a", null, "A", false]]}, + +{"description":"<!DOCTYPE a SYSTEM'B", +"input":"<!DOCTYPE a SYSTEM'B", +"output":["ParseError", "ParseError", ["DOCTYPE", "a", null, "B", false]]}, + +{"description":"<!DOCTYPE a SYSTEM'Y", +"input":"<!DOCTYPE a SYSTEM'Y", +"output":["ParseError", "ParseError", ["DOCTYPE", "a", null, "Y", false]]}, + +{"description":"<!DOCTYPE a SYSTEM'Z", +"input":"<!DOCTYPE a SYSTEM'Z", +"output":["ParseError", "ParseError", ["DOCTYPE", "a", null, "Z", false]]}, + +{"description":"<!DOCTYPE a SYSTEM'`", +"input":"<!DOCTYPE a SYSTEM'`", +"output":["ParseError", "ParseError", ["DOCTYPE", "a", null, "`", false]]}, + +{"description":"<!DOCTYPE a SYSTEM'a", +"input":"<!DOCTYPE a SYSTEM'a", +"output":["ParseError", "ParseError", ["DOCTYPE", "a", null, "a", false]]}, + +{"description":"<!DOCTYPE a SYSTEM'b", +"input":"<!DOCTYPE a SYSTEM'b", +"output":["ParseError", "ParseError", ["DOCTYPE", "a", null, "b", false]]}, + +{"description":"<!DOCTYPE a SYSTEM'y", +"input":"<!DOCTYPE a SYSTEM'y", +"output":["ParseError", "ParseError", ["DOCTYPE", "a", null, "y", false]]}, + +{"description":"<!DOCTYPE a SYSTEM'z", +"input":"<!DOCTYPE a SYSTEM'z", +"output":["ParseError", "ParseError", ["DOCTYPE", "a", null, "z", false]]}, + +{"description":"<!DOCTYPE a SYSTEM'{", +"input":"<!DOCTYPE a SYSTEM'{", +"output":["ParseError", "ParseError", ["DOCTYPE", "a", null, "{", false]]}, + +{"description":"<!DOCTYPE a SYSTEM'\\uDBC0\\uDC00", +"input":"<!DOCTYPE a SYSTEM'\uDBC0\uDC00", +"output":["ParseError", "ParseError", ["DOCTYPE", "a", null, "\uDBC0\uDC00", false]]}, + +{"description":"<!DOCTYPE a SYSTEM(", +"input":"<!DOCTYPE a SYSTEM(", +"output":["ParseError", ["DOCTYPE", "a", null, null, false]]}, + +{"description":"<!DOCTYPE a SYSTEM-", +"input":"<!DOCTYPE a SYSTEM-", +"output":["ParseError", ["DOCTYPE", "a", null, null, false]]}, + +{"description":"<!DOCTYPE a SYSTEM/", +"input":"<!DOCTYPE a SYSTEM/", +"output":["ParseError", ["DOCTYPE", "a", null, null, false]]}, + +{"description":"<!DOCTYPE a SYSTEM0", +"input":"<!DOCTYPE a SYSTEM0", +"output":["ParseError", ["DOCTYPE", "a", null, null, false]]}, + +{"description":"<!DOCTYPE a SYSTEM1", +"input":"<!DOCTYPE a SYSTEM1", +"output":["ParseError", ["DOCTYPE", "a", null, null, false]]}, + +{"description":"<!DOCTYPE a SYSTEM9", +"input":"<!DOCTYPE a SYSTEM9", +"output":["ParseError", ["DOCTYPE", "a", null, null, false]]}, + +{"description":"<!DOCTYPE a SYSTEM<", +"input":"<!DOCTYPE a SYSTEM<", +"output":["ParseError", ["DOCTYPE", "a", null, null, false]]}, + +{"description":"<!DOCTYPE a SYSTEM=", +"input":"<!DOCTYPE a SYSTEM=", +"output":["ParseError", ["DOCTYPE", "a", null, null, false]]}, + +{"description":"<!DOCTYPE a SYSTEM>", +"input":"<!DOCTYPE a SYSTEM>", +"output":["ParseError", ["DOCTYPE", "a", null, null, false]]}, + +{"description":"<!DOCTYPE a SYSTEM?", +"input":"<!DOCTYPE a SYSTEM?", +"output":["ParseError", ["DOCTYPE", "a", null, null, false]]}, + +{"description":"<!DOCTYPE a SYSTEM@", +"input":"<!DOCTYPE a SYSTEM@", +"output":["ParseError", ["DOCTYPE", "a", null, null, false]]}, + +{"description":"<!DOCTYPE a SYSTEMA", +"input":"<!DOCTYPE a SYSTEMA", +"output":["ParseError", ["DOCTYPE", "a", null, null, false]]}, + +{"description":"<!DOCTYPE a SYSTEMB", +"input":"<!DOCTYPE a SYSTEMB", +"output":["ParseError", ["DOCTYPE", "a", null, null, false]]}, + +{"description":"<!DOCTYPE a SYSTEMY", +"input":"<!DOCTYPE a SYSTEMY", +"output":["ParseError", ["DOCTYPE", "a", null, null, false]]}, + +{"description":"<!DOCTYPE a SYSTEMZ", +"input":"<!DOCTYPE a SYSTEMZ", +"output":["ParseError", ["DOCTYPE", "a", null, null, false]]}, + +{"description":"<!DOCTYPE a SYSTEM`", +"input":"<!DOCTYPE a SYSTEM`", +"output":["ParseError", ["DOCTYPE", "a", null, null, false]]}, + +{"description":"<!DOCTYPE a SYSTEMa", +"input":"<!DOCTYPE a SYSTEMa", +"output":["ParseError", ["DOCTYPE", "a", null, null, false]]}, + +{"description":"<!DOCTYPE a SYSTEMb", +"input":"<!DOCTYPE a SYSTEMb", +"output":["ParseError", ["DOCTYPE", "a", null, null, false]]}, + +{"description":"<!DOCTYPE a SYSTEMy", +"input":"<!DOCTYPE a SYSTEMy", +"output":["ParseError", ["DOCTYPE", "a", null, null, false]]}, + +{"description":"<!DOCTYPE a SYSTEMz", +"input":"<!DOCTYPE a SYSTEMz", +"output":["ParseError", ["DOCTYPE", "a", null, null, false]]}, + +{"description":"<!DOCTYPE a SYSTEM{", +"input":"<!DOCTYPE a SYSTEM{", +"output":["ParseError", ["DOCTYPE", "a", null, null, false]]}, + +{"description":"<!DOCTYPE a SYSTEM\\uDBC0\\uDC00", +"input":"<!DOCTYPE a SYSTEM\uDBC0\uDC00", +"output":["ParseError", ["DOCTYPE", "a", null, null, false]]}, + +{"description":"<!DOCTYPE a Y", +"input":"<!DOCTYPE a Y", +"output":["ParseError", ["DOCTYPE", "a", null, null, false]]}, + +{"description":"<!DOCTYPE a Z", +"input":"<!DOCTYPE a Z", +"output":["ParseError", ["DOCTYPE", "a", null, null, false]]}, + +{"description":"<!DOCTYPE a `", +"input":"<!DOCTYPE a `", +"output":["ParseError", ["DOCTYPE", "a", null, null, false]]}, + +{"description":"<!DOCTYPE a a", +"input":"<!DOCTYPE a a", +"output":["ParseError", ["DOCTYPE", "a", null, null, false]]}, + +{"description":"<!DOCTYPE a a\\u0000", +"input":"<!DOCTYPE a a\u0000", +"output":["ParseError", ["DOCTYPE", "a", null, null, false]]}, + +{"description":"<!DOCTYPE a a\\u0009", +"input":"<!DOCTYPE a a\u0009", +"output":["ParseError", ["DOCTYPE", "a", null, null, false]]}, + +{"description":"<!DOCTYPE a a\\u000A", +"input":"<!DOCTYPE a a\u000A", +"output":["ParseError", ["DOCTYPE", "a", null, null, false]]}, + +{"description":"<!DOCTYPE a a\\u000B", +"input":"<!DOCTYPE a a\u000B", +"output":["ParseError", "ParseError", ["DOCTYPE", "a", null, null, false]]}, + +{"description":"<!DOCTYPE a a\\u000C", +"input":"<!DOCTYPE a a\u000C", +"output":["ParseError", ["DOCTYPE", "a", null, null, false]]}, + +{"description":"<!DOCTYPE a a ", +"input":"<!DOCTYPE a a ", +"output":["ParseError", ["DOCTYPE", "a", null, null, false]]}, + +{"description":"<!DOCTYPE a a!", +"input":"<!DOCTYPE a a!", +"output":["ParseError", ["DOCTYPE", "a", null, null, false]]}, + +{"description":"<!DOCTYPE a a\"", +"input":"<!DOCTYPE a a\"", +"output":["ParseError", ["DOCTYPE", "a", null, null, false]]}, + +{"description":"<!DOCTYPE a a&", +"input":"<!DOCTYPE a a&", +"output":["ParseError", ["DOCTYPE", "a", null, null, false]]}, + +{"description":"<!DOCTYPE a a'", +"input":"<!DOCTYPE a a'", +"output":["ParseError", ["DOCTYPE", "a", null, null, false]]}, + +{"description":"<!DOCTYPE a a-", +"input":"<!DOCTYPE a a-", +"output":["ParseError", ["DOCTYPE", "a", null, null, false]]}, + +{"description":"<!DOCTYPE a a/", +"input":"<!DOCTYPE a a/", +"output":["ParseError", ["DOCTYPE", "a", null, null, false]]}, + +{"description":"<!DOCTYPE a a0", +"input":"<!DOCTYPE a a0", +"output":["ParseError", ["DOCTYPE", "a", null, null, false]]}, + +{"description":"<!DOCTYPE a a1", +"input":"<!DOCTYPE a a1", +"output":["ParseError", ["DOCTYPE", "a", null, null, false]]}, + +{"description":"<!DOCTYPE a a9", +"input":"<!DOCTYPE a a9", +"output":["ParseError", ["DOCTYPE", "a", null, null, false]]}, + +{"description":"<!DOCTYPE a a<", +"input":"<!DOCTYPE a a<", +"output":["ParseError", ["DOCTYPE", "a", null, null, false]]}, + +{"description":"<!DOCTYPE a a=", +"input":"<!DOCTYPE a a=", +"output":["ParseError", ["DOCTYPE", "a", null, null, false]]}, + +{"description":"<!DOCTYPE a a>", +"input":"<!DOCTYPE a a>", +"output":["ParseError", ["DOCTYPE", "a", null, null, false]]}, + +{"description":"<!DOCTYPE a a?", +"input":"<!DOCTYPE a a?", +"output":["ParseError", ["DOCTYPE", "a", null, null, false]]}, + +{"description":"<!DOCTYPE a a@", +"input":"<!DOCTYPE a a@", +"output":["ParseError", ["DOCTYPE", "a", null, null, false]]}, + +{"description":"<!DOCTYPE a aA", +"input":"<!DOCTYPE a aA", +"output":["ParseError", ["DOCTYPE", "a", null, null, false]]}, + +{"description":"<!DOCTYPE a aB", +"input":"<!DOCTYPE a aB", +"output":["ParseError", ["DOCTYPE", "a", null, null, false]]}, + +{"description":"<!DOCTYPE a aY", +"input":"<!DOCTYPE a aY", +"output":["ParseError", ["DOCTYPE", "a", null, null, false]]}, + +{"description":"<!DOCTYPE a aZ", +"input":"<!DOCTYPE a aZ", +"output":["ParseError", ["DOCTYPE", "a", null, null, false]]}, + +{"description":"<!DOCTYPE a a`", +"input":"<!DOCTYPE a a`", +"output":["ParseError", ["DOCTYPE", "a", null, null, false]]}, + +{"description":"<!DOCTYPE a aa", +"input":"<!DOCTYPE a aa", +"output":["ParseError", ["DOCTYPE", "a", null, null, false]]}, + +{"description":"<!DOCTYPE a ab", +"input":"<!DOCTYPE a ab", +"output":["ParseError", ["DOCTYPE", "a", null, null, false]]}, + +{"description":"<!DOCTYPE a ay", +"input":"<!DOCTYPE a ay", +"output":["ParseError", ["DOCTYPE", "a", null, null, false]]}, + +{"description":"<!DOCTYPE a az", +"input":"<!DOCTYPE a az", +"output":["ParseError", ["DOCTYPE", "a", null, null, false]]}, + +{"description":"<!DOCTYPE a a{", +"input":"<!DOCTYPE a a{", +"output":["ParseError", ["DOCTYPE", "a", null, null, false]]}, + +{"description":"<!DOCTYPE a a\\uDBC0\\uDC00", +"input":"<!DOCTYPE a a\uDBC0\uDC00", +"output":["ParseError", ["DOCTYPE", "a", null, null, false]]}, + +{"description":"<!DOCTYPE a b", +"input":"<!DOCTYPE a b", +"output":["ParseError", ["DOCTYPE", "a", null, null, false]]}, + +{"description":"<!DOCTYPE a y", +"input":"<!DOCTYPE a y", +"output":["ParseError", ["DOCTYPE", "a", null, null, false]]}, + +{"description":"<!DOCTYPE a z", +"input":"<!DOCTYPE a z", +"output":["ParseError", ["DOCTYPE", "a", null, null, false]]}, + +{"description":"<!DOCTYPE a {", +"input":"<!DOCTYPE a {", +"output":["ParseError", ["DOCTYPE", "a", null, null, false]]}, + +{"description":"<!DOCTYPE a \\uDBC0\\uDC00", +"input":"<!DOCTYPE a \uDBC0\uDC00", +"output":["ParseError", ["DOCTYPE", "a", null, null, false]]}, + +{"description":"<!DOCTYPE a!", +"input":"<!DOCTYPE a!", +"output":["ParseError", ["DOCTYPE", "a!", null, null, false]]}, + +{"description":"<!DOCTYPE a\"", +"input":"<!DOCTYPE a\"", +"output":["ParseError", ["DOCTYPE", "a\"", null, null, false]]}, + +{"description":"<!DOCTYPE a&", +"input":"<!DOCTYPE a&", +"output":["ParseError", ["DOCTYPE", "a&", null, null, false]]}, + +{"description":"<!DOCTYPE a'", +"input":"<!DOCTYPE a'", +"output":["ParseError", ["DOCTYPE", "a'", null, null, false]]}, + +{"description":"<!DOCTYPE a-", +"input":"<!DOCTYPE a-", +"output":["ParseError", ["DOCTYPE", "a-", null, null, false]]}, + +{"description":"<!DOCTYPE a/", +"input":"<!DOCTYPE a/", +"output":["ParseError", ["DOCTYPE", "a/", null, null, false]]}, + +{"description":"<!DOCTYPE a0", +"input":"<!DOCTYPE a0", +"output":["ParseError", ["DOCTYPE", "a0", null, null, false]]}, + +{"description":"<!DOCTYPE a1", +"input":"<!DOCTYPE a1", +"output":["ParseError", ["DOCTYPE", "a1", null, null, false]]}, + +{"description":"<!DOCTYPE a9", +"input":"<!DOCTYPE a9", +"output":["ParseError", ["DOCTYPE", "a9", null, null, false]]}, + +{"description":"<!DOCTYPE a<", +"input":"<!DOCTYPE a<", +"output":["ParseError", ["DOCTYPE", "a<", null, null, false]]}, + +{"description":"<!DOCTYPE a=", +"input":"<!DOCTYPE a=", +"output":["ParseError", ["DOCTYPE", "a=", null, null, false]]}, + +{"description":"<!DOCTYPE a>", +"input":"<!DOCTYPE a>", +"output":[["DOCTYPE", "a", null, null, true]]}, + +{"description":"<!DOCTYPE a?", +"input":"<!DOCTYPE a?", +"output":["ParseError", ["DOCTYPE", "a?", null, null, false]]}, + +{"description":"<!DOCTYPE a@", +"input":"<!DOCTYPE a@", +"output":["ParseError", ["DOCTYPE", "a@", null, null, false]]}, + +{"description":"<!DOCTYPE aA", +"input":"<!DOCTYPE aA", +"output":["ParseError", ["DOCTYPE", "aa", null, null, false]]}, + +{"description":"<!DOCTYPE aB", +"input":"<!DOCTYPE aB", +"output":["ParseError", ["DOCTYPE", "ab", null, null, false]]}, + +{"description":"<!DOCTYPE aY", +"input":"<!DOCTYPE aY", +"output":["ParseError", ["DOCTYPE", "ay", null, null, false]]}, + +{"description":"<!DOCTYPE aZ", +"input":"<!DOCTYPE aZ", +"output":["ParseError", ["DOCTYPE", "az", null, null, false]]}, + +{"description":"<!DOCTYPE a[", +"input":"<!DOCTYPE a[", +"output":["ParseError", ["DOCTYPE", "a[", null, null, false]]}, + +{"description":"<!DOCTYPE a`", +"input":"<!DOCTYPE a`", +"output":["ParseError", ["DOCTYPE", "a`", null, null, false]]}, + +{"description":"<!DOCTYPE aa", +"input":"<!DOCTYPE aa", +"output":["ParseError", ["DOCTYPE", "aa", null, null, false]]}, + +{"description":"<!DOCTYPE ab", +"input":"<!DOCTYPE ab", +"output":["ParseError", ["DOCTYPE", "ab", null, null, false]]}, + +{"description":"<!DOCTYPE ay", +"input":"<!DOCTYPE ay", +"output":["ParseError", ["DOCTYPE", "ay", null, null, false]]}, + +{"description":"<!DOCTYPE az", +"input":"<!DOCTYPE az", +"output":["ParseError", ["DOCTYPE", "az", null, null, false]]}, + +{"description":"<!DOCTYPE a{", +"input":"<!DOCTYPE a{", +"output":["ParseError", ["DOCTYPE", "a{", null, null, false]]}, + +{"description":"<!DOCTYPE a\\uDBC0\\uDC00", +"input":"<!DOCTYPE a\uDBC0\uDC00", +"output":["ParseError", ["DOCTYPE", "a\uDBC0\uDC00", null, null, false]]}, + +{"description":"<!DOCTYPE b", +"input":"<!DOCTYPE b", +"output":["ParseError", ["DOCTYPE", "b", null, null, false]]}, + +{"description":"<!DOCTYPE y", +"input":"<!DOCTYPE y", +"output":["ParseError", ["DOCTYPE", "y", null, null, false]]}, + +{"description":"<!DOCTYPE z", +"input":"<!DOCTYPE z", +"output":["ParseError", ["DOCTYPE", "z", null, null, false]]}, + +{"description":"<!DOCTYPE {", +"input":"<!DOCTYPE {", +"output":["ParseError", ["DOCTYPE", "{", null, null, false]]}, + +{"description":"<!DOCTYPE \\uDBC0\\uDC00", +"input":"<!DOCTYPE \uDBC0\uDC00", +"output":["ParseError", ["DOCTYPE", "\uDBC0\uDC00", null, null, false]]}, + +{"description":"<!DOCTYPE!", +"input":"<!DOCTYPE!", +"output":["ParseError", "ParseError", ["DOCTYPE", "!", null, null, false]]}, + +{"description":"<!DOCTYPE\"", +"input":"<!DOCTYPE\"", +"output":["ParseError", "ParseError", ["DOCTYPE", "\"", null, null, false]]}, + +{"description":"<!DOCTYPE&", +"input":"<!DOCTYPE&", +"output":["ParseError", "ParseError", ["DOCTYPE", "&", null, null, false]]}, + +{"description":"<!DOCTYPE'", +"input":"<!DOCTYPE'", +"output":["ParseError", "ParseError", ["DOCTYPE", "'", null, null, false]]}, + +{"description":"<!DOCTYPE-", +"input":"<!DOCTYPE-", +"output":["ParseError", "ParseError", ["DOCTYPE", "-", null, null, false]]}, + +{"description":"<!DOCTYPE/", +"input":"<!DOCTYPE/", +"output":["ParseError", "ParseError", ["DOCTYPE", "/", null, null, false]]}, + +{"description":"<!DOCTYPE0", +"input":"<!DOCTYPE0", +"output":["ParseError", "ParseError", ["DOCTYPE", "0", null, null, false]]}, + +{"description":"<!DOCTYPE1", +"input":"<!DOCTYPE1", +"output":["ParseError", "ParseError", ["DOCTYPE", "1", null, null, false]]}, + +{"description":"<!DOCTYPE9", +"input":"<!DOCTYPE9", +"output":["ParseError", "ParseError", ["DOCTYPE", "9", null, null, false]]}, + +{"description":"<!DOCTYPE<", +"input":"<!DOCTYPE<", +"output":["ParseError", "ParseError", ["DOCTYPE", "<", null, null, false]]}, + +{"description":"<!DOCTYPE=", +"input":"<!DOCTYPE=", +"output":["ParseError", "ParseError", ["DOCTYPE", "=", null, null, false]]}, + +{"description":"<!DOCTYPE>", +"input":"<!DOCTYPE>", +"output":["ParseError", "ParseError", ["DOCTYPE", "", null, null, false]]}, + +{"description":"<!DOCTYPE?", +"input":"<!DOCTYPE?", +"output":["ParseError", "ParseError", ["DOCTYPE", "?", null, null, false]]}, + +{"description":"<!DOCTYPE@", +"input":"<!DOCTYPE@", +"output":["ParseError", "ParseError", ["DOCTYPE", "@", null, null, false]]}, + +{"description":"<!DOCTYPEA", +"input":"<!DOCTYPEA", +"output":["ParseError", "ParseError", ["DOCTYPE", "a", null, null, false]]}, + +{"description":"<!DOCTYPEB", +"input":"<!DOCTYPEB", +"output":["ParseError", "ParseError", ["DOCTYPE", "b", null, null, false]]}, + +{"description":"<!DOCTYPEY", +"input":"<!DOCTYPEY", +"output":["ParseError", "ParseError", ["DOCTYPE", "y", null, null, false]]}, + +{"description":"<!DOCTYPEZ", +"input":"<!DOCTYPEZ", +"output":["ParseError", "ParseError", ["DOCTYPE", "z", null, null, false]]}, + +{"description":"<!DOCTYPE`", +"input":"<!DOCTYPE`", +"output":["ParseError", "ParseError", ["DOCTYPE", "`", null, null, false]]}, + +{"description":"<!DOCTYPEa", +"input":"<!DOCTYPEa", +"output":["ParseError", "ParseError", ["DOCTYPE", "a", null, null, false]]}, + +{"description":"<!DOCTYPEa\\u0000", +"input":"<!DOCTYPEa\u0000", +"output":["ParseError", "ParseError", "ParseError", ["DOCTYPE", "a\uFFFD", null, null, false]]}, + +{"description":"<!DOCTYPEa\\u0008", +"input":"<!DOCTYPEa\u0008", +"output":["ParseError", "ParseError", "ParseError", ["DOCTYPE", "a\u0008", null, null, false]]}, + +{"description":"<!DOCTYPEa\\u0009", +"input":"<!DOCTYPEa\u0009", +"output":["ParseError", "ParseError", ["DOCTYPE", "a", null, null, false]]}, + +{"description":"<!DOCTYPEa\\u000A", +"input":"<!DOCTYPEa\u000A", +"output":["ParseError", "ParseError", ["DOCTYPE", "a", null, null, false]]}, + +{"description":"<!DOCTYPEa\\u000B", +"input":"<!DOCTYPEa\u000B", +"output":["ParseError", "ParseError", "ParseError", ["DOCTYPE", "a\u000B", null, null, false]]}, + +{"description":"<!DOCTYPEa\\u000C", +"input":"<!DOCTYPEa\u000C", +"output":["ParseError", "ParseError", ["DOCTYPE", "a", null, null, false]]}, + +{"description":"<!DOCTYPEa\\u000D", +"input":"<!DOCTYPEa\u000D", +"output":["ParseError", "ParseError", ["DOCTYPE", "a", null, null, false]]}, + +{"description":"<!DOCTYPEa\\u001F", +"input":"<!DOCTYPEa\u001F", +"output":["ParseError", "ParseError", "ParseError", ["DOCTYPE", "a\u001F", null, null, false]]}, + +{"description":"<!DOCTYPEa ", +"input":"<!DOCTYPEa ", +"output":["ParseError", "ParseError", ["DOCTYPE", "a", null, null, false]]}, + +{"description":"<!DOCTYPEa \\u0000", +"input":"<!DOCTYPEa \u0000", +"output":["ParseError", "ParseError", ["DOCTYPE", "a", null, null, false]]}, + +{"description":"<!DOCTYPEa \\u0008", +"input":"<!DOCTYPEa \u0008", +"output":["ParseError", "ParseError", "ParseError", ["DOCTYPE", "a", null, null, false]]}, + +{"description":"<!DOCTYPEa \\u0009", +"input":"<!DOCTYPEa \u0009", +"output":["ParseError", "ParseError", ["DOCTYPE", "a", null, null, false]]}, + +{"description":"<!DOCTYPEa \\u000A", +"input":"<!DOCTYPEa \u000A", +"output":["ParseError", "ParseError", ["DOCTYPE", "a", null, null, false]]}, + +{"description":"<!DOCTYPEa \\u000B", +"input":"<!DOCTYPEa \u000B", +"output":["ParseError", "ParseError", "ParseError", ["DOCTYPE", "a", null, null, false]]}, + +{"description":"<!DOCTYPEa \\u000C", +"input":"<!DOCTYPEa \u000C", +"output":["ParseError", "ParseError", ["DOCTYPE", "a", null, null, false]]}, + +{"description":"<!DOCTYPEa \\u000D", +"input":"<!DOCTYPEa \u000D", +"output":["ParseError", "ParseError", ["DOCTYPE", "a", null, null, false]]}, + +{"description":"<!DOCTYPEa \\u001F", +"input":"<!DOCTYPEa \u001F", +"output":["ParseError", "ParseError", "ParseError", ["DOCTYPE", "a", null, null, false]]}, + +{"description":"<!DOCTYPEa ", +"input":"<!DOCTYPEa ", +"output":["ParseError", "ParseError", ["DOCTYPE", "a", null, null, false]]}, + +{"description":"<!DOCTYPEa !", +"input":"<!DOCTYPEa !", +"output":["ParseError", "ParseError", ["DOCTYPE", "a", null, null, false]]}, + +{"description":"<!DOCTYPEa \"", +"input":"<!DOCTYPEa \"", +"output":["ParseError", "ParseError", ["DOCTYPE", "a", null, null, false]]}, + +{"description":"<!DOCTYPEa &", +"input":"<!DOCTYPEa &", +"output":["ParseError", "ParseError", ["DOCTYPE", "a", null, null, false]]}, + +{"description":"<!DOCTYPEa '", +"input":"<!DOCTYPEa '", +"output":["ParseError", "ParseError", ["DOCTYPE", "a", null, null, false]]}, + +{"description":"<!DOCTYPEa -", +"input":"<!DOCTYPEa -", +"output":["ParseError", "ParseError", ["DOCTYPE", "a", null, null, false]]}, + +{"description":"<!DOCTYPEa /", +"input":"<!DOCTYPEa /", +"output":["ParseError", "ParseError", ["DOCTYPE", "a", null, null, false]]}, + +{"description":"<!DOCTYPEa 0", +"input":"<!DOCTYPEa 0", +"output":["ParseError", "ParseError", ["DOCTYPE", "a", null, null, false]]}, + +{"description":"<!DOCTYPEa 1", +"input":"<!DOCTYPEa 1", +"output":["ParseError", "ParseError", ["DOCTYPE", "a", null, null, false]]}, + +{"description":"<!DOCTYPEa 9", +"input":"<!DOCTYPEa 9", +"output":["ParseError", "ParseError", ["DOCTYPE", "a", null, null, false]]}, + +{"description":"<!DOCTYPEa <", +"input":"<!DOCTYPEa <", +"output":["ParseError", "ParseError", ["DOCTYPE", "a", null, null, false]]}, + +{"description":"<!DOCTYPEa =", +"input":"<!DOCTYPEa =", +"output":["ParseError", "ParseError", ["DOCTYPE", "a", null, null, false]]}, + +{"description":"<!DOCTYPEa >", +"input":"<!DOCTYPEa >", +"output":["ParseError", ["DOCTYPE", "a", null, null, true]]}, + +{"description":"<!DOCTYPEa ?", +"input":"<!DOCTYPEa ?", +"output":["ParseError", "ParseError", ["DOCTYPE", "a", null, null, false]]}, + +{"description":"<!DOCTYPEa @", +"input":"<!DOCTYPEa @", +"output":["ParseError", "ParseError", ["DOCTYPE", "a", null, null, false]]}, + +{"description":"<!DOCTYPEa A", +"input":"<!DOCTYPEa A", +"output":["ParseError", "ParseError", ["DOCTYPE", "a", null, null, false]]}, + +{"description":"<!DOCTYPEa B", +"input":"<!DOCTYPEa B", +"output":["ParseError", "ParseError", ["DOCTYPE", "a", null, null, false]]}, + +{"description":"<!DOCTYPEa PUBLIC", +"input":"<!DOCTYPEa PUBLIC", +"output":["ParseError", "ParseError", ["DOCTYPE", "a", null, null, false]]}, + +{"description":"<!DOCTYPEa PUBLIC\\u0000", +"input":"<!DOCTYPEa PUBLIC\u0000", +"output":["ParseError", "ParseError", ["DOCTYPE", "a", null, null, false]]}, + +{"description":"<!DOCTYPEa PUBLIC\\u0008", +"input":"<!DOCTYPEa PUBLIC\u0008", +"output":["ParseError", "ParseError", "ParseError", ["DOCTYPE", "a", null, null, false]]}, + +{"description":"<!DOCTYPEa PUBLIC\\u0009", +"input":"<!DOCTYPEa PUBLIC\u0009", +"output":["ParseError", "ParseError", ["DOCTYPE", "a", null, null, false]]}, + +{"description":"<!DOCTYPEa PUBLIC\\u000A", +"input":"<!DOCTYPEa PUBLIC\u000A", +"output":["ParseError", "ParseError", ["DOCTYPE", "a", null, null, false]]}, + +{"description":"<!DOCTYPEa PUBLIC\\u000B", +"input":"<!DOCTYPEa PUBLIC\u000B", +"output":["ParseError", "ParseError", "ParseError", ["DOCTYPE", "a", null, null, false]]}, + +{"description":"<!DOCTYPEa PUBLIC\\u000C", +"input":"<!DOCTYPEa PUBLIC\u000C", +"output":["ParseError", "ParseError", ["DOCTYPE", "a", null, null, false]]}, + +{"description":"<!DOCTYPEa PUBLIC\\u000D", +"input":"<!DOCTYPEa PUBLIC\u000D", +"output":["ParseError", "ParseError", ["DOCTYPE", "a", null, null, false]]}, + +{"description":"<!DOCTYPEa PUBLIC\\u001F", +"input":"<!DOCTYPEa PUBLIC\u001F", +"output":["ParseError", "ParseError", "ParseError", ["DOCTYPE", "a", null, null, false]]}, + +{"description":"<!DOCTYPEa PUBLIC ", +"input":"<!DOCTYPEa PUBLIC ", +"output":["ParseError", "ParseError", ["DOCTYPE", "a", null, null, false]]}, + +{"description":"<!DOCTYPEa PUBLIC!", +"input":"<!DOCTYPEa PUBLIC!", +"output":["ParseError", "ParseError", ["DOCTYPE", "a", null, null, false]]}, + +{"description":"<!DOCTYPEa PUBLIC\"", +"input":"<!DOCTYPEa PUBLIC\"", +"output":["ParseError", "ParseError", "ParseError", ["DOCTYPE", "a", "", null, false]]}, + +{"description":"<!DOCTYPEa PUBLIC\"\\u0000", +"input":"<!DOCTYPEa PUBLIC\"\u0000", +"output":["ParseError", "ParseError", "ParseError", "ParseError", ["DOCTYPE", "a", "\uFFFD", null, false]]}, + +{"description":"<!DOCTYPEa PUBLIC\"\\u0009", +"input":"<!DOCTYPEa PUBLIC\"\u0009", +"output":["ParseError", "ParseError", "ParseError", ["DOCTYPE", "a", "\u0009", null, false]]}, + +{"description":"<!DOCTYPEa PUBLIC\"\\u000A", +"input":"<!DOCTYPEa PUBLIC\"\u000A", +"output":["ParseError", "ParseError", "ParseError", ["DOCTYPE", "a", "\u000A", null, false]]}, + +{"description":"<!DOCTYPEa PUBLIC\"\\u000B", +"input":"<!DOCTYPEa PUBLIC\"\u000B", +"output":["ParseError", "ParseError", "ParseError", "ParseError", ["DOCTYPE", "a", "\u000B", null, false]]}, + +{"description":"<!DOCTYPEa PUBLIC\"\\u000C", +"input":"<!DOCTYPEa PUBLIC\"\u000C", +"output":["ParseError", "ParseError", "ParseError", ["DOCTYPE", "a", "\u000C", null, false]]}, + +{"description":"<!DOCTYPEa PUBLIC\" ", +"input":"<!DOCTYPEa PUBLIC\" ", +"output":["ParseError", "ParseError", "ParseError", ["DOCTYPE", "a", " ", null, false]]}, + +{"description":"<!DOCTYPEa PUBLIC\"!", +"input":"<!DOCTYPEa PUBLIC\"!", +"output":["ParseError", "ParseError", "ParseError", ["DOCTYPE", "a", "!", null, false]]}, + +{"description":"<!DOCTYPEa PUBLIC\"\"", +"input":"<!DOCTYPEa PUBLIC\"\"", +"output":["ParseError", "ParseError", "ParseError", ["DOCTYPE", "a", "", null, false]]}, + +{"description":"<!DOCTYPEa PUBLIC\"#", +"input":"<!DOCTYPEa PUBLIC\"#", +"output":["ParseError", "ParseError", "ParseError", ["DOCTYPE", "a", "#", null, false]]}, + +{"description":"<!DOCTYPEa PUBLIC\"&", +"input":"<!DOCTYPEa PUBLIC\"&", +"output":["ParseError", "ParseError", "ParseError", ["DOCTYPE", "a", "&", null, false]]}, + +{"description":"<!DOCTYPEa PUBLIC\"'", +"input":"<!DOCTYPEa PUBLIC\"'", +"output":["ParseError", "ParseError", "ParseError", ["DOCTYPE", "a", "'", null, false]]}, + +{"description":"<!DOCTYPEa PUBLIC\"-", +"input":"<!DOCTYPEa PUBLIC\"-", +"output":["ParseError", "ParseError", "ParseError", ["DOCTYPE", "a", "-", null, false]]}, + +{"description":"<!DOCTYPEa PUBLIC\"/", +"input":"<!DOCTYPEa PUBLIC\"/", +"output":["ParseError", "ParseError", "ParseError", ["DOCTYPE", "a", "/", null, false]]}, + +{"description":"<!DOCTYPEa PUBLIC\"0", +"input":"<!DOCTYPEa PUBLIC\"0", +"output":["ParseError", "ParseError", "ParseError", ["DOCTYPE", "a", "0", null, false]]}, + +{"description":"<!DOCTYPEa PUBLIC\"1", +"input":"<!DOCTYPEa PUBLIC\"1", +"output":["ParseError", "ParseError", "ParseError", ["DOCTYPE", "a", "1", null, false]]}, + +{"description":"<!DOCTYPEa PUBLIC\"9", +"input":"<!DOCTYPEa PUBLIC\"9", +"output":["ParseError", "ParseError", "ParseError", ["DOCTYPE", "a", "9", null, false]]}, + +{"description":"<!DOCTYPEa PUBLIC\"<", +"input":"<!DOCTYPEa PUBLIC\"<", +"output":["ParseError", "ParseError", "ParseError", ["DOCTYPE", "a", "<", null, false]]}, + +{"description":"<!DOCTYPEa PUBLIC\"=", +"input":"<!DOCTYPEa PUBLIC\"=", +"output":["ParseError", "ParseError", "ParseError", ["DOCTYPE", "a", "=", null, false]]}, + +{"description":"<!DOCTYPEa PUBLIC\">", +"input":"<!DOCTYPEa PUBLIC\">", +"output":["ParseError", "ParseError", "ParseError", ["DOCTYPE", "a", "", null, false]]}, + +{"description":"<!DOCTYPEa PUBLIC\"?", +"input":"<!DOCTYPEa PUBLIC\"?", +"output":["ParseError", "ParseError", "ParseError", ["DOCTYPE", "a", "?", null, false]]}, + +{"description":"<!DOCTYPEa PUBLIC\"@", +"input":"<!DOCTYPEa PUBLIC\"@", +"output":["ParseError", "ParseError", "ParseError", ["DOCTYPE", "a", "@", null, false]]}, + +{"description":"<!DOCTYPEa PUBLIC\"A", +"input":"<!DOCTYPEa PUBLIC\"A", +"output":["ParseError", "ParseError", "ParseError", ["DOCTYPE", "a", "A", null, false]]}, + +{"description":"<!DOCTYPEa PUBLIC\"B", +"input":"<!DOCTYPEa PUBLIC\"B", +"output":["ParseError", "ParseError", "ParseError", ["DOCTYPE", "a", "B", null, false]]}, + +{"description":"<!DOCTYPEa PUBLIC\"Y", +"input":"<!DOCTYPEa PUBLIC\"Y", +"output":["ParseError", "ParseError", "ParseError", ["DOCTYPE", "a", "Y", null, false]]}, + +{"description":"<!DOCTYPEa PUBLIC\"Z", +"input":"<!DOCTYPEa PUBLIC\"Z", +"output":["ParseError", "ParseError", "ParseError", ["DOCTYPE", "a", "Z", null, false]]}, + +{"description":"<!DOCTYPEa PUBLIC\"`", +"input":"<!DOCTYPEa PUBLIC\"`", +"output":["ParseError", "ParseError", "ParseError", ["DOCTYPE", "a", "`", null, false]]}, + +{"description":"<!DOCTYPEa PUBLIC\"a", +"input":"<!DOCTYPEa PUBLIC\"a", +"output":["ParseError", "ParseError", "ParseError", ["DOCTYPE", "a", "a", null, false]]}, + +{"description":"<!DOCTYPEa PUBLIC\"b", +"input":"<!DOCTYPEa PUBLIC\"b", +"output":["ParseError", "ParseError", "ParseError", ["DOCTYPE", "a", "b", null, false]]}, + +{"description":"<!DOCTYPEa PUBLIC\"y", +"input":"<!DOCTYPEa PUBLIC\"y", +"output":["ParseError", "ParseError", "ParseError", ["DOCTYPE", "a", "y", null, false]]}, + +{"description":"<!DOCTYPEa PUBLIC\"z", +"input":"<!DOCTYPEa PUBLIC\"z", +"output":["ParseError", "ParseError", "ParseError", ["DOCTYPE", "a", "z", null, false]]}, + +{"description":"<!DOCTYPEa PUBLIC\"{", +"input":"<!DOCTYPEa PUBLIC\"{", +"output":["ParseError", "ParseError", "ParseError", ["DOCTYPE", "a", "{", null, false]]}, + +{"description":"<!DOCTYPEa PUBLIC\"\\uDBC0\\uDC00", +"input":"<!DOCTYPEa PUBLIC\"\uDBC0\uDC00", +"output":["ParseError", "ParseError", "ParseError", ["DOCTYPE", "a", "\uDBC0\uDC00", null, false]]}, + +{"description":"<!DOCTYPEa PUBLIC#", +"input":"<!DOCTYPEa PUBLIC#", +"output":["ParseError", "ParseError", ["DOCTYPE", "a", null, null, false]]}, + +{"description":"<!DOCTYPEa PUBLIC&", +"input":"<!DOCTYPEa PUBLIC&", +"output":["ParseError", "ParseError", ["DOCTYPE", "a", null, null, false]]}, + +{"description":"<!DOCTYPEa PUBLIC'", +"input":"<!DOCTYPEa PUBLIC'", +"output":["ParseError", "ParseError", "ParseError", ["DOCTYPE", "a", "", null, false]]}, + +{"description":"<!DOCTYPEa PUBLIC'\\u0000", +"input":"<!DOCTYPEa PUBLIC'\u0000", +"output":["ParseError", "ParseError", "ParseError", "ParseError", ["DOCTYPE", "a", "\uFFFD", null, false]]}, + +{"description":"<!DOCTYPEa PUBLIC'\\u0009", +"input":"<!DOCTYPEa PUBLIC'\u0009", +"output":["ParseError", "ParseError", "ParseError", ["DOCTYPE", "a", "\u0009", null, false]]}, + +{"description":"<!DOCTYPEa PUBLIC'\\u000A", +"input":"<!DOCTYPEa PUBLIC'\u000A", +"output":["ParseError", "ParseError", "ParseError", ["DOCTYPE", "a", "\u000A", null, false]]}, + +{"description":"<!DOCTYPEa PUBLIC'\\u000B", +"input":"<!DOCTYPEa PUBLIC'\u000B", +"output":["ParseError", "ParseError", "ParseError", "ParseError", ["DOCTYPE", "a", "\u000B", null, false]]}, + +{"description":"<!DOCTYPEa PUBLIC'\\u000C", +"input":"<!DOCTYPEa PUBLIC'\u000C", +"output":["ParseError", "ParseError", "ParseError", ["DOCTYPE", "a", "\u000C", null, false]]}, + +{"description":"<!DOCTYPEa PUBLIC' ", +"input":"<!DOCTYPEa PUBLIC' ", +"output":["ParseError", "ParseError", "ParseError", ["DOCTYPE", "a", " ", null, false]]}, + +{"description":"<!DOCTYPEa PUBLIC'!", +"input":"<!DOCTYPEa PUBLIC'!", +"output":["ParseError", "ParseError", "ParseError", ["DOCTYPE", "a", "!", null, false]]}, + +{"description":"<!DOCTYPEa PUBLIC'\"", +"input":"<!DOCTYPEa PUBLIC'\"", +"output":["ParseError", "ParseError", "ParseError", ["DOCTYPE", "a", "\"", null, false]]}, + +{"description":"<!DOCTYPEa PUBLIC'&", +"input":"<!DOCTYPEa PUBLIC'&", +"output":["ParseError", "ParseError", "ParseError", ["DOCTYPE", "a", "&", null, false]]}, + +{"description":"<!DOCTYPEa PUBLIC''", +"input":"<!DOCTYPEa PUBLIC''", +"output":["ParseError", "ParseError", "ParseError", ["DOCTYPE", "a", "", null, false]]}, + +{"description":"<!DOCTYPEa PUBLIC''\\u0000", +"input":"<!DOCTYPEa PUBLIC''\u0000", +"output":["ParseError", "ParseError", "ParseError", ["DOCTYPE", "a", "", null, false]]}, + +{"description":"<!DOCTYPEa PUBLIC''\\u0008", +"input":"<!DOCTYPEa PUBLIC''\u0008", +"output":["ParseError", "ParseError", "ParseError", "ParseError", ["DOCTYPE", "a", "", null, false]]}, + +{"description":"<!DOCTYPEa PUBLIC''\\u0009", +"input":"<!DOCTYPEa PUBLIC''\u0009", +"output":["ParseError", "ParseError", "ParseError", ["DOCTYPE", "a", "", null, false]]}, + +{"description":"<!DOCTYPEa PUBLIC''\\u000A", +"input":"<!DOCTYPEa PUBLIC''\u000A", +"output":["ParseError", "ParseError", "ParseError", ["DOCTYPE", "a", "", null, false]]}, + +{"description":"<!DOCTYPEa PUBLIC''\\u000B", +"input":"<!DOCTYPEa PUBLIC''\u000B", +"output":["ParseError", "ParseError", "ParseError", "ParseError", ["DOCTYPE", "a", "", null, false]]}, + +{"description":"<!DOCTYPEa PUBLIC''\\u000C", +"input":"<!DOCTYPEa PUBLIC''\u000C", +"output":["ParseError", "ParseError", "ParseError", ["DOCTYPE", "a", "", null, false]]}, + +{"description":"<!DOCTYPEa PUBLIC''\\u000D", +"input":"<!DOCTYPEa PUBLIC''\u000D", +"output":["ParseError", "ParseError", "ParseError", ["DOCTYPE", "a", "", null, false]]}, + +{"description":"<!DOCTYPEa PUBLIC''\\u001F", +"input":"<!DOCTYPEa PUBLIC''\u001F", +"output":["ParseError", "ParseError", "ParseError", "ParseError", ["DOCTYPE", "a", "", null, false]]}, + +{"description":"<!DOCTYPEa PUBLIC'' ", +"input":"<!DOCTYPEa PUBLIC'' ", +"output":["ParseError", "ParseError", "ParseError", ["DOCTYPE", "a", "", null, false]]}, + +{"description":"<!DOCTYPEa PUBLIC''!", +"input":"<!DOCTYPEa PUBLIC''!", +"output":["ParseError", "ParseError", "ParseError", ["DOCTYPE", "a", "", null, false]]}, + +{"description":"<!DOCTYPEa PUBLIC''\"", +"input":"<!DOCTYPEa PUBLIC''\"", +"output":["ParseError", "ParseError", "ParseError", "ParseError", ["DOCTYPE", "a", "", "", false]]}, + +{"description":"<!DOCTYPEa PUBLIC''#", +"input":"<!DOCTYPEa PUBLIC''#", +"output":["ParseError", "ParseError", "ParseError", ["DOCTYPE", "a", "", null, false]]}, + +{"description":"<!DOCTYPEa PUBLIC''&", +"input":"<!DOCTYPEa PUBLIC''&", +"output":["ParseError", "ParseError", "ParseError", ["DOCTYPE", "a", "", null, false]]}, + +{"description":"<!DOCTYPEa PUBLIC'''", +"input":"<!DOCTYPEa PUBLIC'''", +"output":["ParseError", "ParseError", "ParseError", "ParseError", ["DOCTYPE", "a", "", "", false]]}, + +{"description":"<!DOCTYPEa PUBLIC''(", +"input":"<!DOCTYPEa PUBLIC''(", +"output":["ParseError", "ParseError", "ParseError", ["DOCTYPE", "a", "", null, false]]}, + +{"description":"<!DOCTYPEa PUBLIC''-", +"input":"<!DOCTYPEa PUBLIC''-", +"output":["ParseError", "ParseError", "ParseError", ["DOCTYPE", "a", "", null, false]]}, + +{"description":"<!DOCTYPEa PUBLIC''/", +"input":"<!DOCTYPEa PUBLIC''/", +"output":["ParseError", "ParseError", "ParseError", ["DOCTYPE", "a", "", null, false]]}, + +{"description":"<!DOCTYPEa PUBLIC''0", +"input":"<!DOCTYPEa PUBLIC''0", +"output":["ParseError", "ParseError", "ParseError", ["DOCTYPE", "a", "", null, false]]}, + +{"description":"<!DOCTYPEa PUBLIC''1", +"input":"<!DOCTYPEa PUBLIC''1", +"output":["ParseError", "ParseError", "ParseError", ["DOCTYPE", "a", "", null, false]]}, + +{"description":"<!DOCTYPEa PUBLIC''9", +"input":"<!DOCTYPEa PUBLIC''9", +"output":["ParseError", "ParseError", "ParseError", ["DOCTYPE", "a", "", null, false]]}, + +{"description":"<!DOCTYPEa PUBLIC''<", +"input":"<!DOCTYPEa PUBLIC''<", +"output":["ParseError", "ParseError", "ParseError", ["DOCTYPE", "a", "", null, false]]}, + +{"description":"<!DOCTYPEa PUBLIC''=", +"input":"<!DOCTYPEa PUBLIC''=", +"output":["ParseError", "ParseError", "ParseError", ["DOCTYPE", "a", "", null, false]]}, + +{"description":"<!DOCTYPEa PUBLIC''>", +"input":"<!DOCTYPEa PUBLIC''>", +"output":["ParseError", "ParseError", ["DOCTYPE", "a", "", null, true]]}, + +{"description":"<!DOCTYPEa PUBLIC''?", +"input":"<!DOCTYPEa PUBLIC''?", +"output":["ParseError", "ParseError", "ParseError", ["DOCTYPE", "a", "", null, false]]}, + +{"description":"<!DOCTYPEa PUBLIC''@", +"input":"<!DOCTYPEa PUBLIC''@", +"output":["ParseError", "ParseError", "ParseError", ["DOCTYPE", "a", "", null, false]]}, + +{"description":"<!DOCTYPEa PUBLIC''A", +"input":"<!DOCTYPEa PUBLIC''A", +"output":["ParseError", "ParseError", "ParseError", ["DOCTYPE", "a", "", null, false]]}, + +{"description":"<!DOCTYPEa PUBLIC''B", +"input":"<!DOCTYPEa PUBLIC''B", +"output":["ParseError", "ParseError", "ParseError", ["DOCTYPE", "a", "", null, false]]}, + +{"description":"<!DOCTYPEa PUBLIC''Y", +"input":"<!DOCTYPEa PUBLIC''Y", +"output":["ParseError", "ParseError", "ParseError", ["DOCTYPE", "a", "", null, false]]}, + +{"description":"<!DOCTYPEa PUBLIC''Z", +"input":"<!DOCTYPEa PUBLIC''Z", +"output":["ParseError", "ParseError", "ParseError", ["DOCTYPE", "a", "", null, false]]}, + +{"description":"<!DOCTYPEa PUBLIC''`", +"input":"<!DOCTYPEa PUBLIC''`", +"output":["ParseError", "ParseError", "ParseError", ["DOCTYPE", "a", "", null, false]]}, + +{"description":"<!DOCTYPEa PUBLIC''a", +"input":"<!DOCTYPEa PUBLIC''a", +"output":["ParseError", "ParseError", "ParseError", ["DOCTYPE", "a", "", null, false]]}, + +{"description":"<!DOCTYPEa PUBLIC''b", +"input":"<!DOCTYPEa PUBLIC''b", +"output":["ParseError", "ParseError", "ParseError", ["DOCTYPE", "a", "", null, false]]}, + +{"description":"<!DOCTYPEa PUBLIC''y", +"input":"<!DOCTYPEa PUBLIC''y", +"output":["ParseError", "ParseError", "ParseError", ["DOCTYPE", "a", "", null, false]]}, + +{"description":"<!DOCTYPEa PUBLIC''z", +"input":"<!DOCTYPEa PUBLIC''z", +"output":["ParseError", "ParseError", "ParseError", ["DOCTYPE", "a", "", null, false]]}, + +{"description":"<!DOCTYPEa PUBLIC''{", +"input":"<!DOCTYPEa PUBLIC''{", +"output":["ParseError", "ParseError", "ParseError", ["DOCTYPE", "a", "", null, false]]}, + +{"description":"<!DOCTYPEa PUBLIC''\\uDBC0\\uDC00", +"input":"<!DOCTYPEa PUBLIC''\uDBC0\uDC00", +"output":["ParseError", "ParseError", "ParseError", ["DOCTYPE", "a", "", null, false]]}, + +{"description":"<!DOCTYPEa PUBLIC'(", +"input":"<!DOCTYPEa PUBLIC'(", +"output":["ParseError", "ParseError", "ParseError", ["DOCTYPE", "a", "(", null, false]]}, + +{"description":"<!DOCTYPEa PUBLIC'-", +"input":"<!DOCTYPEa PUBLIC'-", +"output":["ParseError", "ParseError", "ParseError", ["DOCTYPE", "a", "-", null, false]]}, + +{"description":"<!DOCTYPEa PUBLIC'/", +"input":"<!DOCTYPEa PUBLIC'/", +"output":["ParseError", "ParseError", "ParseError", ["DOCTYPE", "a", "/", null, false]]}, + +{"description":"<!DOCTYPEa PUBLIC'0", +"input":"<!DOCTYPEa PUBLIC'0", +"output":["ParseError", "ParseError", "ParseError", ["DOCTYPE", "a", "0", null, false]]}, + +{"description":"<!DOCTYPEa PUBLIC'1", +"input":"<!DOCTYPEa PUBLIC'1", +"output":["ParseError", "ParseError", "ParseError", ["DOCTYPE", "a", "1", null, false]]}, + +{"description":"<!DOCTYPEa PUBLIC'9", +"input":"<!DOCTYPEa PUBLIC'9", +"output":["ParseError", "ParseError", "ParseError", ["DOCTYPE", "a", "9", null, false]]}, + +{"description":"<!DOCTYPEa PUBLIC'<", +"input":"<!DOCTYPEa PUBLIC'<", +"output":["ParseError", "ParseError", "ParseError", ["DOCTYPE", "a", "<", null, false]]}, + +{"description":"<!DOCTYPEa PUBLIC'=", +"input":"<!DOCTYPEa PUBLIC'=", +"output":["ParseError", "ParseError", "ParseError", ["DOCTYPE", "a", "=", null, false]]}, + +{"description":"<!DOCTYPEa PUBLIC'>", +"input":"<!DOCTYPEa PUBLIC'>", +"output":["ParseError", "ParseError", "ParseError", ["DOCTYPE", "a", "", null, false]]}, + +{"description":"<!DOCTYPEa PUBLIC'?", +"input":"<!DOCTYPEa PUBLIC'?", +"output":["ParseError", "ParseError", "ParseError", ["DOCTYPE", "a", "?", null, false]]}, + +{"description":"<!DOCTYPEa PUBLIC'@", +"input":"<!DOCTYPEa PUBLIC'@", +"output":["ParseError", "ParseError", "ParseError", ["DOCTYPE", "a", "@", null, false]]}, + +{"description":"<!DOCTYPEa PUBLIC'A", +"input":"<!DOCTYPEa PUBLIC'A", +"output":["ParseError", "ParseError", "ParseError", ["DOCTYPE", "a", "A", null, false]]}, + +{"description":"<!DOCTYPEa PUBLIC'B", +"input":"<!DOCTYPEa PUBLIC'B", +"output":["ParseError", "ParseError", "ParseError", ["DOCTYPE", "a", "B", null, false]]}, + +{"description":"<!DOCTYPEa PUBLIC'Y", +"input":"<!DOCTYPEa PUBLIC'Y", +"output":["ParseError", "ParseError", "ParseError", ["DOCTYPE", "a", "Y", null, false]]}, + +{"description":"<!DOCTYPEa PUBLIC'Z", +"input":"<!DOCTYPEa PUBLIC'Z", +"output":["ParseError", "ParseError", "ParseError", ["DOCTYPE", "a", "Z", null, false]]}, + +{"description":"<!DOCTYPEa PUBLIC'`", +"input":"<!DOCTYPEa PUBLIC'`", +"output":["ParseError", "ParseError", "ParseError", ["DOCTYPE", "a", "`", null, false]]}, + +{"description":"<!DOCTYPEa PUBLIC'a", +"input":"<!DOCTYPEa PUBLIC'a", +"output":["ParseError", "ParseError", "ParseError", ["DOCTYPE", "a", "a", null, false]]}, + +{"description":"<!DOCTYPEa PUBLIC'b", +"input":"<!DOCTYPEa PUBLIC'b", +"output":["ParseError", "ParseError", "ParseError", ["DOCTYPE", "a", "b", null, false]]}, + +{"description":"<!DOCTYPEa PUBLIC'y", +"input":"<!DOCTYPEa PUBLIC'y", +"output":["ParseError", "ParseError", "ParseError", ["DOCTYPE", "a", "y", null, false]]}, + +{"description":"<!DOCTYPEa PUBLIC'z", +"input":"<!DOCTYPEa PUBLIC'z", +"output":["ParseError", "ParseError", "ParseError", ["DOCTYPE", "a", "z", null, false]]}, + +{"description":"<!DOCTYPEa PUBLIC'{", +"input":"<!DOCTYPEa PUBLIC'{", +"output":["ParseError", "ParseError", "ParseError", ["DOCTYPE", "a", "{", null, false]]}, + +{"description":"<!DOCTYPEa PUBLIC'\\uDBC0\\uDC00", +"input":"<!DOCTYPEa PUBLIC'\uDBC0\uDC00", +"output":["ParseError", "ParseError", "ParseError", ["DOCTYPE", "a", "\uDBC0\uDC00", null, false]]}, + +{"description":"<!DOCTYPEa PUBLIC(", +"input":"<!DOCTYPEa PUBLIC(", +"output":["ParseError", "ParseError", ["DOCTYPE", "a", null, null, false]]}, + +{"description":"<!DOCTYPEa PUBLIC-", +"input":"<!DOCTYPEa PUBLIC-", +"output":["ParseError", "ParseError", ["DOCTYPE", "a", null, null, false]]}, + +{"description":"<!DOCTYPEa PUBLIC/", +"input":"<!DOCTYPEa PUBLIC/", +"output":["ParseError", "ParseError", ["DOCTYPE", "a", null, null, false]]}, + +{"description":"<!DOCTYPEa PUBLIC0", +"input":"<!DOCTYPEa PUBLIC0", +"output":["ParseError", "ParseError", ["DOCTYPE", "a", null, null, false]]}, + +{"description":"<!DOCTYPEa PUBLIC1", +"input":"<!DOCTYPEa PUBLIC1", +"output":["ParseError", "ParseError", ["DOCTYPE", "a", null, null, false]]}, + +{"description":"<!DOCTYPEa PUBLIC9", +"input":"<!DOCTYPEa PUBLIC9", +"output":["ParseError", "ParseError", ["DOCTYPE", "a", null, null, false]]}, + +{"description":"<!DOCTYPEa PUBLIC<", +"input":"<!DOCTYPEa PUBLIC<", +"output":["ParseError", "ParseError", ["DOCTYPE", "a", null, null, false]]}, + +{"description":"<!DOCTYPEa PUBLIC=", +"input":"<!DOCTYPEa PUBLIC=", +"output":["ParseError", "ParseError", ["DOCTYPE", "a", null, null, false]]}, + +{"description":"<!DOCTYPEa PUBLIC>", +"input":"<!DOCTYPEa PUBLIC>", +"output":["ParseError", "ParseError", ["DOCTYPE", "a", null, null, false]]}, + +{"description":"<!DOCTYPEa PUBLIC?", +"input":"<!DOCTYPEa PUBLIC?", +"output":["ParseError", "ParseError", ["DOCTYPE", "a", null, null, false]]}, + +{"description":"<!DOCTYPEa PUBLIC@", +"input":"<!DOCTYPEa PUBLIC@", +"output":["ParseError", "ParseError", ["DOCTYPE", "a", null, null, false]]}, + +{"description":"<!DOCTYPEa PUBLICA", +"input":"<!DOCTYPEa PUBLICA", +"output":["ParseError", "ParseError", ["DOCTYPE", "a", null, null, false]]}, + +{"description":"<!DOCTYPEa PUBLICB", +"input":"<!DOCTYPEa PUBLICB", +"output":["ParseError", "ParseError", ["DOCTYPE", "a", null, null, false]]}, + +{"description":"<!DOCTYPEa PUBLICY", +"input":"<!DOCTYPEa PUBLICY", +"output":["ParseError", "ParseError", ["DOCTYPE", "a", null, null, false]]}, + +{"description":"<!DOCTYPEa PUBLICZ", +"input":"<!DOCTYPEa PUBLICZ", +"output":["ParseError", "ParseError", ["DOCTYPE", "a", null, null, false]]}, + +{"description":"<!DOCTYPEa PUBLIC`", +"input":"<!DOCTYPEa PUBLIC`", +"output":["ParseError", "ParseError", ["DOCTYPE", "a", null, null, false]]}, + +{"description":"<!DOCTYPEa PUBLICa", +"input":"<!DOCTYPEa PUBLICa", +"output":["ParseError", "ParseError", ["DOCTYPE", "a", null, null, false]]}, + +{"description":"<!DOCTYPEa PUBLICb", +"input":"<!DOCTYPEa PUBLICb", +"output":["ParseError", "ParseError", ["DOCTYPE", "a", null, null, false]]}, + +{"description":"<!DOCTYPEa PUBLICy", +"input":"<!DOCTYPEa PUBLICy", +"output":["ParseError", "ParseError", ["DOCTYPE", "a", null, null, false]]}, + +{"description":"<!DOCTYPEa PUBLICz", +"input":"<!DOCTYPEa PUBLICz", +"output":["ParseError", "ParseError", ["DOCTYPE", "a", null, null, false]]}, + +{"description":"<!DOCTYPEa PUBLIC{", +"input":"<!DOCTYPEa PUBLIC{", +"output":["ParseError", "ParseError", ["DOCTYPE", "a", null, null, false]]}, + +{"description":"<!DOCTYPEa PUBLIC\\uDBC0\\uDC00", +"input":"<!DOCTYPEa PUBLIC\uDBC0\uDC00", +"output":["ParseError", "ParseError", ["DOCTYPE", "a", null, null, false]]}, + +{"description":"<!DOCTYPEa SYSTEM", +"input":"<!DOCTYPEa SYSTEM", +"output":["ParseError", "ParseError", ["DOCTYPE", "a", null, null, false]]}, + +{"description":"<!DOCTYPEa SYSTEM\\u0000", +"input":"<!DOCTYPEa SYSTEM\u0000", +"output":["ParseError", "ParseError", ["DOCTYPE", "a", null, null, false]]}, + +{"description":"<!DOCTYPEa SYSTEM\\u0008", +"input":"<!DOCTYPEa SYSTEM\u0008", +"output":["ParseError", "ParseError", "ParseError", ["DOCTYPE", "a", null, null, false]]}, + +{"description":"<!DOCTYPEa SYSTEM\\u0009", +"input":"<!DOCTYPEa SYSTEM\u0009", +"output":["ParseError", "ParseError", ["DOCTYPE", "a", null, null, false]]}, + +{"description":"<!DOCTYPEa SYSTEM\\u000A", +"input":"<!DOCTYPEa SYSTEM\u000A", +"output":["ParseError", "ParseError", ["DOCTYPE", "a", null, null, false]]}, + +{"description":"<!DOCTYPEa SYSTEM\\u000B", +"input":"<!DOCTYPEa SYSTEM\u000B", +"output":["ParseError", "ParseError", "ParseError", ["DOCTYPE", "a", null, null, false]]}, + +{"description":"<!DOCTYPEa SYSTEM\\u000C", +"input":"<!DOCTYPEa SYSTEM\u000C", +"output":["ParseError", "ParseError", ["DOCTYPE", "a", null, null, false]]}, + +{"description":"<!DOCTYPEa SYSTEM\\u000D", +"input":"<!DOCTYPEa SYSTEM\u000D", +"output":["ParseError", "ParseError", ["DOCTYPE", "a", null, null, false]]}, + +{"description":"<!DOCTYPEa SYSTEM\\u001F", +"input":"<!DOCTYPEa SYSTEM\u001F", +"output":["ParseError", "ParseError", "ParseError", ["DOCTYPE", "a", null, null, false]]}, + +{"description":"<!DOCTYPEa SYSTEM ", +"input":"<!DOCTYPEa SYSTEM ", +"output":["ParseError", "ParseError", ["DOCTYPE", "a", null, null, false]]}, + +{"description":"<!DOCTYPEa SYSTEM!", +"input":"<!DOCTYPEa SYSTEM!", +"output":["ParseError", "ParseError", ["DOCTYPE", "a", null, null, false]]}, + +{"description":"<!DOCTYPEa SYSTEM\"", +"input":"<!DOCTYPEa SYSTEM\"", +"output":["ParseError", "ParseError", "ParseError", ["DOCTYPE", "a", null, "", false]]}, + +{"description":"<!DOCTYPEa SYSTEM\"\\u0000", +"input":"<!DOCTYPEa SYSTEM\"\u0000", +"output":["ParseError", "ParseError", "ParseError", "ParseError", ["DOCTYPE", "a", null, "\uFFFD", false]]}, + +{"description":"<!DOCTYPEa SYSTEM\"\\u0009", +"input":"<!DOCTYPEa SYSTEM\"\u0009", +"output":["ParseError", "ParseError", "ParseError", ["DOCTYPE", "a", null, "\u0009", false]]}, + +{"description":"<!DOCTYPEa SYSTEM\"\\u000A", +"input":"<!DOCTYPEa SYSTEM\"\u000A", +"output":["ParseError", "ParseError", "ParseError", ["DOCTYPE", "a", null, "\u000A", false]]}, + +{"description":"<!DOCTYPEa SYSTEM\"\\u000B", +"input":"<!DOCTYPEa SYSTEM\"\u000B", +"output":["ParseError", "ParseError", "ParseError", "ParseError", ["DOCTYPE", "a", null, "\u000B", false]]}, + +{"description":"<!DOCTYPEa SYSTEM\"\\u000C", +"input":"<!DOCTYPEa SYSTEM\"\u000C", +"output":["ParseError", "ParseError", "ParseError", ["DOCTYPE", "a", null, "\u000C", false]]}, + +{"description":"<!DOCTYPEa SYSTEM\" ", +"input":"<!DOCTYPEa SYSTEM\" ", +"output":["ParseError", "ParseError", "ParseError", ["DOCTYPE", "a", null, " ", false]]}, + +{"description":"<!DOCTYPEa SYSTEM\"!", +"input":"<!DOCTYPEa SYSTEM\"!", +"output":["ParseError", "ParseError", "ParseError", ["DOCTYPE", "a", null, "!", false]]}, + +{"description":"<!DOCTYPEa SYSTEM\"\"", +"input":"<!DOCTYPEa SYSTEM\"\"", +"output":["ParseError", "ParseError", "ParseError", ["DOCTYPE", "a", null, "", false]]}, + +{"description":"<!DOCTYPEa SYSTEM\"#", +"input":"<!DOCTYPEa SYSTEM\"#", +"output":["ParseError", "ParseError", "ParseError", ["DOCTYPE", "a", null, "#", false]]}, + +{"description":"<!DOCTYPEa SYSTEM\"&", +"input":"<!DOCTYPEa SYSTEM\"&", +"output":["ParseError", "ParseError", "ParseError", ["DOCTYPE", "a", null, "&", false]]}, + +{"description":"<!DOCTYPEa SYSTEM\"'", +"input":"<!DOCTYPEa SYSTEM\"'", +"output":["ParseError", "ParseError", "ParseError", ["DOCTYPE", "a", null, "'", false]]}, + +{"description":"<!DOCTYPEa SYSTEM\"-", +"input":"<!DOCTYPEa SYSTEM\"-", +"output":["ParseError", "ParseError", "ParseError", ["DOCTYPE", "a", null, "-", false]]}, + +{"description":"<!DOCTYPEa SYSTEM\"/", +"input":"<!DOCTYPEa SYSTEM\"/", +"output":["ParseError", "ParseError", "ParseError", ["DOCTYPE", "a", null, "/", false]]}, + +{"description":"<!DOCTYPEa SYSTEM\"0", +"input":"<!DOCTYPEa SYSTEM\"0", +"output":["ParseError", "ParseError", "ParseError", ["DOCTYPE", "a", null, "0", false]]}, + +{"description":"<!DOCTYPEa SYSTEM\"1", +"input":"<!DOCTYPEa SYSTEM\"1", +"output":["ParseError", "ParseError", "ParseError", ["DOCTYPE", "a", null, "1", false]]}, + +{"description":"<!DOCTYPEa SYSTEM\"9", +"input":"<!DOCTYPEa SYSTEM\"9", +"output":["ParseError", "ParseError", "ParseError", ["DOCTYPE", "a", null, "9", false]]}, + +{"description":"<!DOCTYPEa SYSTEM\"<", +"input":"<!DOCTYPEa SYSTEM\"<", +"output":["ParseError", "ParseError", "ParseError", ["DOCTYPE", "a", null, "<", false]]}, + +{"description":"<!DOCTYPEa SYSTEM\"=", +"input":"<!DOCTYPEa SYSTEM\"=", +"output":["ParseError", "ParseError", "ParseError", ["DOCTYPE", "a", null, "=", false]]}, + +{"description":"<!DOCTYPEa SYSTEM\">", +"input":"<!DOCTYPEa SYSTEM\">", +"output":["ParseError", "ParseError", "ParseError", ["DOCTYPE", "a", null, "", false]]}, + +{"description":"<!DOCTYPEa SYSTEM\"?", +"input":"<!DOCTYPEa SYSTEM\"?", +"output":["ParseError", "ParseError", "ParseError", ["DOCTYPE", "a", null, "?", false]]}, + +{"description":"<!DOCTYPEa SYSTEM\"@", +"input":"<!DOCTYPEa SYSTEM\"@", +"output":["ParseError", "ParseError", "ParseError", ["DOCTYPE", "a", null, "@", false]]}, + +{"description":"<!DOCTYPEa SYSTEM\"A", +"input":"<!DOCTYPEa SYSTEM\"A", +"output":["ParseError", "ParseError", "ParseError", ["DOCTYPE", "a", null, "A", false]]}, + +{"description":"<!DOCTYPEa SYSTEM\"B", +"input":"<!DOCTYPEa SYSTEM\"B", +"output":["ParseError", "ParseError", "ParseError", ["DOCTYPE", "a", null, "B", false]]}, + +{"description":"<!DOCTYPEa SYSTEM\"Y", +"input":"<!DOCTYPEa SYSTEM\"Y", +"output":["ParseError", "ParseError", "ParseError", ["DOCTYPE", "a", null, "Y", false]]}, + +{"description":"<!DOCTYPEa SYSTEM\"Z", +"input":"<!DOCTYPEa SYSTEM\"Z", +"output":["ParseError", "ParseError", "ParseError", ["DOCTYPE", "a", null, "Z", false]]}, + +{"description":"<!DOCTYPEa SYSTEM\"`", +"input":"<!DOCTYPEa SYSTEM\"`", +"output":["ParseError", "ParseError", "ParseError", ["DOCTYPE", "a", null, "`", false]]}, + +{"description":"<!DOCTYPEa SYSTEM\"a", +"input":"<!DOCTYPEa SYSTEM\"a", +"output":["ParseError", "ParseError", "ParseError", ["DOCTYPE", "a", null, "a", false]]}, + +{"description":"<!DOCTYPEa SYSTEM\"b", +"input":"<!DOCTYPEa SYSTEM\"b", +"output":["ParseError", "ParseError", "ParseError", ["DOCTYPE", "a", null, "b", false]]}, + +{"description":"<!DOCTYPEa SYSTEM\"y", +"input":"<!DOCTYPEa SYSTEM\"y", +"output":["ParseError", "ParseError", "ParseError", ["DOCTYPE", "a", null, "y", false]]}, + +{"description":"<!DOCTYPEa SYSTEM\"z", +"input":"<!DOCTYPEa SYSTEM\"z", +"output":["ParseError", "ParseError", "ParseError", ["DOCTYPE", "a", null, "z", false]]}, + +{"description":"<!DOCTYPEa SYSTEM\"{", +"input":"<!DOCTYPEa SYSTEM\"{", +"output":["ParseError", "ParseError", "ParseError", ["DOCTYPE", "a", null, "{", false]]}, + +{"description":"<!DOCTYPEa SYSTEM\"\\uDBC0\\uDC00", +"input":"<!DOCTYPEa SYSTEM\"\uDBC0\uDC00", +"output":["ParseError", "ParseError", "ParseError", ["DOCTYPE", "a", null, "\uDBC0\uDC00", false]]}, + +{"description":"<!DOCTYPEa SYSTEM#", +"input":"<!DOCTYPEa SYSTEM#", +"output":["ParseError", "ParseError", ["DOCTYPE", "a", null, null, false]]}, + +{"description":"<!DOCTYPEa SYSTEM&", +"input":"<!DOCTYPEa SYSTEM&", +"output":["ParseError", "ParseError", ["DOCTYPE", "a", null, null, false]]}, + +{"description":"<!DOCTYPEa SYSTEM'", +"input":"<!DOCTYPEa SYSTEM'", +"output":["ParseError", "ParseError", "ParseError", ["DOCTYPE", "a", null, "", false]]}, + +{"description":"<!DOCTYPEa SYSTEM'\\u0000", +"input":"<!DOCTYPEa SYSTEM'\u0000", +"output":["ParseError", "ParseError", "ParseError", "ParseError", ["DOCTYPE", "a", null, "\uFFFD", false]]}, + +{"description":"<!DOCTYPEa SYSTEM'\\u0009", +"input":"<!DOCTYPEa SYSTEM'\u0009", +"output":["ParseError", "ParseError", "ParseError", ["DOCTYPE", "a", null, "\u0009", false]]}, + +{"description":"<!DOCTYPEa SYSTEM'\\u000A", +"input":"<!DOCTYPEa SYSTEM'\u000A", +"output":["ParseError", "ParseError", "ParseError", ["DOCTYPE", "a", null, "\u000A", false]]}, + +{"description":"<!DOCTYPEa SYSTEM'\\u000B", +"input":"<!DOCTYPEa SYSTEM'\u000B", +"output":["ParseError", "ParseError", "ParseError", "ParseError", ["DOCTYPE", "a", null, "\u000B", false]]}, + +{"description":"<!DOCTYPEa SYSTEM'\\u000C", +"input":"<!DOCTYPEa SYSTEM'\u000C", +"output":["ParseError", "ParseError", "ParseError", ["DOCTYPE", "a", null, "\u000C", false]]}, + +{"description":"<!DOCTYPEa SYSTEM' ", +"input":"<!DOCTYPEa SYSTEM' ", +"output":["ParseError", "ParseError", "ParseError", ["DOCTYPE", "a", null, " ", false]]}, + +{"description":"<!DOCTYPEa SYSTEM'!", +"input":"<!DOCTYPEa SYSTEM'!", +"output":["ParseError", "ParseError", "ParseError", ["DOCTYPE", "a", null, "!", false]]}, + +{"description":"<!DOCTYPEa SYSTEM'\"", +"input":"<!DOCTYPEa SYSTEM'\"", +"output":["ParseError", "ParseError", "ParseError", ["DOCTYPE", "a", null, "\"", false]]}, + +{"description":"<!DOCTYPEa SYSTEM'&", +"input":"<!DOCTYPEa SYSTEM'&", +"output":["ParseError", "ParseError", "ParseError", ["DOCTYPE", "a", null, "&", false]]}, + +{"description":"<!DOCTYPEa SYSTEM''", +"input":"<!DOCTYPEa SYSTEM''", +"output":["ParseError", "ParseError", "ParseError", ["DOCTYPE", "a", null, "", false]]}, + +{"description":"<!DOCTYPEa SYSTEM''\\u0000", +"input":"<!DOCTYPEa SYSTEM''\u0000", +"output":["ParseError", "ParseError", "ParseError", ["DOCTYPE", "a", null, "", true]]}, + +{"description":"<!DOCTYPEa SYSTEM''\\u0008", +"input":"<!DOCTYPEa SYSTEM''\u0008", +"output":["ParseError", "ParseError", "ParseError", "ParseError", ["DOCTYPE", "a", null, "", true]]}, + +{"description":"<!DOCTYPEa SYSTEM''\\u0009", +"input":"<!DOCTYPEa SYSTEM''\u0009", +"output":["ParseError", "ParseError", "ParseError", ["DOCTYPE", "a", null, "", false]]}, + +{"description":"<!DOCTYPEa SYSTEM''\\u000A", +"input":"<!DOCTYPEa SYSTEM''\u000A", +"output":["ParseError", "ParseError", "ParseError", ["DOCTYPE", "a", null, "", false]]}, + +{"description":"<!DOCTYPEa SYSTEM''\\u000B", +"input":"<!DOCTYPEa SYSTEM''\u000B", +"output":["ParseError", "ParseError", "ParseError", "ParseError", ["DOCTYPE", "a", null, "", true]]}, + +{"description":"<!DOCTYPEa SYSTEM''\\u000C", +"input":"<!DOCTYPEa SYSTEM''\u000C", +"output":["ParseError", "ParseError", "ParseError", ["DOCTYPE", "a", null, "", false]]}, + +{"description":"<!DOCTYPEa SYSTEM''\\u000D", +"input":"<!DOCTYPEa SYSTEM''\u000D", +"output":["ParseError", "ParseError", "ParseError", ["DOCTYPE", "a", null, "", false]]}, + +{"description":"<!DOCTYPEa SYSTEM''\\u001F", +"input":"<!DOCTYPEa SYSTEM''\u001F", +"output":["ParseError", "ParseError", "ParseError", "ParseError", ["DOCTYPE", "a", null, "", true]]}, + +{"description":"<!DOCTYPEa SYSTEM'' ", +"input":"<!DOCTYPEa SYSTEM'' ", +"output":["ParseError", "ParseError", "ParseError", ["DOCTYPE", "a", null, "", false]]}, + +{"description":"<!DOCTYPEa SYSTEM''!", +"input":"<!DOCTYPEa SYSTEM''!", +"output":["ParseError", "ParseError", "ParseError", ["DOCTYPE", "a", null, "", true]]}, + +{"description":"<!DOCTYPEa SYSTEM''\"", +"input":"<!DOCTYPEa SYSTEM''\"", +"output":["ParseError", "ParseError", "ParseError", ["DOCTYPE", "a", null, "", true]]}, + +{"description":"<!DOCTYPEa SYSTEM''&", +"input":"<!DOCTYPEa SYSTEM''&", +"output":["ParseError", "ParseError", "ParseError", ["DOCTYPE", "a", null, "", true]]}, + +{"description":"<!DOCTYPEa SYSTEM'''", +"input":"<!DOCTYPEa SYSTEM'''", +"output":["ParseError", "ParseError", "ParseError", ["DOCTYPE", "a", null, "", true]]}, + +{"description":"<!DOCTYPEa SYSTEM''-", +"input":"<!DOCTYPEa SYSTEM''-", +"output":["ParseError", "ParseError", "ParseError", ["DOCTYPE", "a", null, "", true]]}, + +{"description":"<!DOCTYPEa SYSTEM''/", +"input":"<!DOCTYPEa SYSTEM''/", +"output":["ParseError", "ParseError", "ParseError", ["DOCTYPE", "a", null, "", true]]}, + +{"description":"<!DOCTYPEa SYSTEM''0", +"input":"<!DOCTYPEa SYSTEM''0", +"output":["ParseError", "ParseError", "ParseError", ["DOCTYPE", "a", null, "", true]]}, + +{"description":"<!DOCTYPEa SYSTEM''1", +"input":"<!DOCTYPEa SYSTEM''1", +"output":["ParseError", "ParseError", "ParseError", ["DOCTYPE", "a", null, "", true]]}, + +{"description":"<!DOCTYPEa SYSTEM''9", +"input":"<!DOCTYPEa SYSTEM''9", +"output":["ParseError", "ParseError", "ParseError", ["DOCTYPE", "a", null, "", true]]}, + +{"description":"<!DOCTYPEa SYSTEM''<", +"input":"<!DOCTYPEa SYSTEM''<", +"output":["ParseError", "ParseError", "ParseError", ["DOCTYPE", "a", null, "", true]]}, + +{"description":"<!DOCTYPEa SYSTEM''=", +"input":"<!DOCTYPEa SYSTEM''=", +"output":["ParseError", "ParseError", "ParseError", ["DOCTYPE", "a", null, "", true]]}, + +{"description":"<!DOCTYPEa SYSTEM''>", +"input":"<!DOCTYPEa SYSTEM''>", +"output":["ParseError", "ParseError", ["DOCTYPE", "a", null, "", true]]}, + +{"description":"<!DOCTYPEa SYSTEM''?", +"input":"<!DOCTYPEa SYSTEM''?", +"output":["ParseError", "ParseError", "ParseError", ["DOCTYPE", "a", null, "", true]]}, + +{"description":"<!DOCTYPEa SYSTEM''@", +"input":"<!DOCTYPEa SYSTEM''@", +"output":["ParseError", "ParseError", "ParseError", ["DOCTYPE", "a", null, "", true]]}, + +{"description":"<!DOCTYPEa SYSTEM''A", +"input":"<!DOCTYPEa SYSTEM''A", +"output":["ParseError", "ParseError", "ParseError", ["DOCTYPE", "a", null, "", true]]}, + +{"description":"<!DOCTYPEa SYSTEM''B", +"input":"<!DOCTYPEa SYSTEM''B", +"output":["ParseError", "ParseError", "ParseError", ["DOCTYPE", "a", null, "", true]]}, + +{"description":"<!DOCTYPEa SYSTEM''Y", +"input":"<!DOCTYPEa SYSTEM''Y", +"output":["ParseError", "ParseError", "ParseError", ["DOCTYPE", "a", null, "", true]]}, + +{"description":"<!DOCTYPEa SYSTEM''Z", +"input":"<!DOCTYPEa SYSTEM''Z", +"output":["ParseError", "ParseError", "ParseError", ["DOCTYPE", "a", null, "", true]]}, + +{"description":"<!DOCTYPEa SYSTEM''`", +"input":"<!DOCTYPEa SYSTEM''`", +"output":["ParseError", "ParseError", "ParseError", ["DOCTYPE", "a", null, "", true]]}, + +{"description":"<!DOCTYPEa SYSTEM''a", +"input":"<!DOCTYPEa SYSTEM''a", +"output":["ParseError", "ParseError", "ParseError", ["DOCTYPE", "a", null, "", true]]}, + +{"description":"<!DOCTYPEa SYSTEM''b", +"input":"<!DOCTYPEa SYSTEM''b", +"output":["ParseError", "ParseError", "ParseError", ["DOCTYPE", "a", null, "", true]]}, + +{"description":"<!DOCTYPEa SYSTEM''y", +"input":"<!DOCTYPEa SYSTEM''y", +"output":["ParseError", "ParseError", "ParseError", ["DOCTYPE", "a", null, "", true]]}, + +{"description":"<!DOCTYPEa SYSTEM''z", +"input":"<!DOCTYPEa SYSTEM''z", +"output":["ParseError", "ParseError", "ParseError", ["DOCTYPE", "a", null, "", true]]}, + +{"description":"<!DOCTYPEa SYSTEM''{", +"input":"<!DOCTYPEa SYSTEM''{", +"output":["ParseError", "ParseError", "ParseError", ["DOCTYPE", "a", null, "", true]]}, + +{"description":"<!DOCTYPEa SYSTEM''\\uDBC0\\uDC00", +"input":"<!DOCTYPEa SYSTEM''\uDBC0\uDC00", +"output":["ParseError", "ParseError", "ParseError", ["DOCTYPE", "a", null, "", true]]}, + +{"description":"<!DOCTYPEa SYSTEM'(", +"input":"<!DOCTYPEa SYSTEM'(", +"output":["ParseError", "ParseError", "ParseError", ["DOCTYPE", "a", null, "(", false]]}, + +{"description":"<!DOCTYPEa SYSTEM'-", +"input":"<!DOCTYPEa SYSTEM'-", +"output":["ParseError", "ParseError", "ParseError", ["DOCTYPE", "a", null, "-", false]]}, + +{"description":"<!DOCTYPEa SYSTEM'/", +"input":"<!DOCTYPEa SYSTEM'/", +"output":["ParseError", "ParseError", "ParseError", ["DOCTYPE", "a", null, "/", false]]}, + +{"description":"<!DOCTYPEa SYSTEM'0", +"input":"<!DOCTYPEa SYSTEM'0", +"output":["ParseError", "ParseError", "ParseError", ["DOCTYPE", "a", null, "0", false]]}, + +{"description":"<!DOCTYPEa SYSTEM'1", +"input":"<!DOCTYPEa SYSTEM'1", +"output":["ParseError", "ParseError", "ParseError", ["DOCTYPE", "a", null, "1", false]]}, + +{"description":"<!DOCTYPEa SYSTEM'9", +"input":"<!DOCTYPEa SYSTEM'9", +"output":["ParseError", "ParseError", "ParseError", ["DOCTYPE", "a", null, "9", false]]}, + +{"description":"<!DOCTYPEa SYSTEM'<", +"input":"<!DOCTYPEa SYSTEM'<", +"output":["ParseError", "ParseError", "ParseError", ["DOCTYPE", "a", null, "<", false]]}, + +{"description":"<!DOCTYPEa SYSTEM'=", +"input":"<!DOCTYPEa SYSTEM'=", +"output":["ParseError", "ParseError", "ParseError", ["DOCTYPE", "a", null, "=", false]]}, + +{"description":"<!DOCTYPEa SYSTEM'>", +"input":"<!DOCTYPEa SYSTEM'>", +"output":["ParseError", "ParseError", "ParseError", ["DOCTYPE", "a", null, "", false]]}, + +{"description":"<!DOCTYPEa SYSTEM'?", +"input":"<!DOCTYPEa SYSTEM'?", +"output":["ParseError", "ParseError", "ParseError", ["DOCTYPE", "a", null, "?", false]]}, + +{"description":"<!DOCTYPEa SYSTEM'@", +"input":"<!DOCTYPEa SYSTEM'@", +"output":["ParseError", "ParseError", "ParseError", ["DOCTYPE", "a", null, "@", false]]}, + +{"description":"<!DOCTYPEa SYSTEM'A", +"input":"<!DOCTYPEa SYSTEM'A", +"output":["ParseError", "ParseError", "ParseError", ["DOCTYPE", "a", null, "A", false]]}, + +{"description":"<!DOCTYPEa SYSTEM'B", +"input":"<!DOCTYPEa SYSTEM'B", +"output":["ParseError", "ParseError", "ParseError", ["DOCTYPE", "a", null, "B", false]]}, + +{"description":"<!DOCTYPEa SYSTEM'Y", +"input":"<!DOCTYPEa SYSTEM'Y", +"output":["ParseError", "ParseError", "ParseError", ["DOCTYPE", "a", null, "Y", false]]}, + +{"description":"<!DOCTYPEa SYSTEM'Z", +"input":"<!DOCTYPEa SYSTEM'Z", +"output":["ParseError", "ParseError", "ParseError", ["DOCTYPE", "a", null, "Z", false]]}, + +{"description":"<!DOCTYPEa SYSTEM'`", +"input":"<!DOCTYPEa SYSTEM'`", +"output":["ParseError", "ParseError", "ParseError", ["DOCTYPE", "a", null, "`", false]]}, + +{"description":"<!DOCTYPEa SYSTEM'a", +"input":"<!DOCTYPEa SYSTEM'a", +"output":["ParseError", "ParseError", "ParseError", ["DOCTYPE", "a", null, "a", false]]}, + +{"description":"<!DOCTYPEa SYSTEM'b", +"input":"<!DOCTYPEa SYSTEM'b", +"output":["ParseError", "ParseError", "ParseError", ["DOCTYPE", "a", null, "b", false]]}, + +{"description":"<!DOCTYPEa SYSTEM'y", +"input":"<!DOCTYPEa SYSTEM'y", +"output":["ParseError", "ParseError", "ParseError", ["DOCTYPE", "a", null, "y", false]]}, + +{"description":"<!DOCTYPEa SYSTEM'z", +"input":"<!DOCTYPEa SYSTEM'z", +"output":["ParseError", "ParseError", "ParseError", ["DOCTYPE", "a", null, "z", false]]}, + +{"description":"<!DOCTYPEa SYSTEM'{", +"input":"<!DOCTYPEa SYSTEM'{", +"output":["ParseError", "ParseError", "ParseError", ["DOCTYPE", "a", null, "{", false]]}, + +{"description":"<!DOCTYPEa SYSTEM'\\uDBC0\\uDC00", +"input":"<!DOCTYPEa SYSTEM'\uDBC0\uDC00", +"output":["ParseError", "ParseError", "ParseError", ["DOCTYPE", "a", null, "\uDBC0\uDC00", false]]}, + +{"description":"<!DOCTYPEa SYSTEM(", +"input":"<!DOCTYPEa SYSTEM(", +"output":["ParseError", "ParseError", ["DOCTYPE", "a", null, null, false]]}, + +{"description":"<!DOCTYPEa SYSTEM-", +"input":"<!DOCTYPEa SYSTEM-", +"output":["ParseError", "ParseError", ["DOCTYPE", "a", null, null, false]]}, + +{"description":"<!DOCTYPEa SYSTEM/", +"input":"<!DOCTYPEa SYSTEM/", +"output":["ParseError", "ParseError", ["DOCTYPE", "a", null, null, false]]}, + +{"description":"<!DOCTYPEa SYSTEM0", +"input":"<!DOCTYPEa SYSTEM0", +"output":["ParseError", "ParseError", ["DOCTYPE", "a", null, null, false]]}, + +{"description":"<!DOCTYPEa SYSTEM1", +"input":"<!DOCTYPEa SYSTEM1", +"output":["ParseError", "ParseError", ["DOCTYPE", "a", null, null, false]]}, + +{"description":"<!DOCTYPEa SYSTEM9", +"input":"<!DOCTYPEa SYSTEM9", +"output":["ParseError", "ParseError", ["DOCTYPE", "a", null, null, false]]}, + +{"description":"<!DOCTYPEa SYSTEM<", +"input":"<!DOCTYPEa SYSTEM<", +"output":["ParseError", "ParseError", ["DOCTYPE", "a", null, null, false]]}, + +{"description":"<!DOCTYPEa SYSTEM=", +"input":"<!DOCTYPEa SYSTEM=", +"output":["ParseError", "ParseError", ["DOCTYPE", "a", null, null, false]]}, + +{"description":"<!DOCTYPEa SYSTEM>", +"input":"<!DOCTYPEa SYSTEM>", +"output":["ParseError", "ParseError", ["DOCTYPE", "a", null, null, false]]}, + +{"description":"<!DOCTYPEa SYSTEM?", +"input":"<!DOCTYPEa SYSTEM?", +"output":["ParseError", "ParseError", ["DOCTYPE", "a", null, null, false]]}, + +{"description":"<!DOCTYPEa SYSTEM@", +"input":"<!DOCTYPEa SYSTEM@", +"output":["ParseError", "ParseError", ["DOCTYPE", "a", null, null, false]]}, + +{"description":"<!DOCTYPEa SYSTEMA", +"input":"<!DOCTYPEa SYSTEMA", +"output":["ParseError", "ParseError", ["DOCTYPE", "a", null, null, false]]}, + +{"description":"<!DOCTYPEa SYSTEMB", +"input":"<!DOCTYPEa SYSTEMB", +"output":["ParseError", "ParseError", ["DOCTYPE", "a", null, null, false]]}, + +{"description":"<!DOCTYPEa SYSTEMY", +"input":"<!DOCTYPEa SYSTEMY", +"output":["ParseError", "ParseError", ["DOCTYPE", "a", null, null, false]]}, + +{"description":"<!DOCTYPEa SYSTEMZ", +"input":"<!DOCTYPEa SYSTEMZ", +"output":["ParseError", "ParseError", ["DOCTYPE", "a", null, null, false]]}, + +{"description":"<!DOCTYPEa SYSTEM`", +"input":"<!DOCTYPEa SYSTEM`", +"output":["ParseError", "ParseError", ["DOCTYPE", "a", null, null, false]]}, + +{"description":"<!DOCTYPEa SYSTEMa", +"input":"<!DOCTYPEa SYSTEMa", +"output":["ParseError", "ParseError", ["DOCTYPE", "a", null, null, false]]}, + +{"description":"<!DOCTYPEa SYSTEMb", +"input":"<!DOCTYPEa SYSTEMb", +"output":["ParseError", "ParseError", ["DOCTYPE", "a", null, null, false]]}, + +{"description":"<!DOCTYPEa SYSTEMy", +"input":"<!DOCTYPEa SYSTEMy", +"output":["ParseError", "ParseError", ["DOCTYPE", "a", null, null, false]]}, + +{"description":"<!DOCTYPEa SYSTEMz", +"input":"<!DOCTYPEa SYSTEMz", +"output":["ParseError", "ParseError", ["DOCTYPE", "a", null, null, false]]}, + +{"description":"<!DOCTYPEa SYSTEM{", +"input":"<!DOCTYPEa SYSTEM{", +"output":["ParseError", "ParseError", ["DOCTYPE", "a", null, null, false]]}, + +{"description":"<!DOCTYPEa SYSTEM\\uDBC0\\uDC00", +"input":"<!DOCTYPEa SYSTEM\uDBC0\uDC00", +"output":["ParseError", "ParseError", ["DOCTYPE", "a", null, null, false]]}, + +{"description":"<!DOCTYPEa Y", +"input":"<!DOCTYPEa Y", +"output":["ParseError", "ParseError", ["DOCTYPE", "a", null, null, false]]}, + +{"description":"<!DOCTYPEa Z", +"input":"<!DOCTYPEa Z", +"output":["ParseError", "ParseError", ["DOCTYPE", "a", null, null, false]]}, + +{"description":"<!DOCTYPEa `", +"input":"<!DOCTYPEa `", +"output":["ParseError", "ParseError", ["DOCTYPE", "a", null, null, false]]}, + +{"description":"<!DOCTYPEa a", +"input":"<!DOCTYPEa a", +"output":["ParseError", "ParseError", ["DOCTYPE", "a", null, null, false]]}, + +{"description":"<!DOCTYPEa a\\u0000", +"input":"<!DOCTYPEa a\u0000", +"output":["ParseError", "ParseError", ["DOCTYPE", "a", null, null, false]]}, + +{"description":"<!DOCTYPEa a\\u0009", +"input":"<!DOCTYPEa a\u0009", +"output":["ParseError", "ParseError", ["DOCTYPE", "a", null, null, false]]}, + +{"description":"<!DOCTYPEa a\\u000A", +"input":"<!DOCTYPEa a\u000A", +"output":["ParseError", "ParseError", ["DOCTYPE", "a", null, null, false]]}, + +{"description":"<!DOCTYPEa a\\u000B", +"input":"<!DOCTYPEa a\u000B", +"output":["ParseError", "ParseError", "ParseError", ["DOCTYPE", "a", null, null, false]]}, + +{"description":"<!DOCTYPEa a\\u000C", +"input":"<!DOCTYPEa a\u000C", +"output":["ParseError", "ParseError", ["DOCTYPE", "a", null, null, false]]}, + +{"description":"<!DOCTYPEa a ", +"input":"<!DOCTYPEa a ", +"output":["ParseError", "ParseError", ["DOCTYPE", "a", null, null, false]]}, + +{"description":"<!DOCTYPEa a!", +"input":"<!DOCTYPEa a!", +"output":["ParseError", "ParseError", ["DOCTYPE", "a", null, null, false]]}, + +{"description":"<!DOCTYPEa a\"", +"input":"<!DOCTYPEa a\"", +"output":["ParseError", "ParseError", ["DOCTYPE", "a", null, null, false]]}, + +{"description":"<!DOCTYPEa a&", +"input":"<!DOCTYPEa a&", +"output":["ParseError", "ParseError", ["DOCTYPE", "a", null, null, false]]}, + +{"description":"<!DOCTYPEa a'", +"input":"<!DOCTYPEa a'", +"output":["ParseError", "ParseError", ["DOCTYPE", "a", null, null, false]]}, + +{"description":"<!DOCTYPEa a-", +"input":"<!DOCTYPEa a-", +"output":["ParseError", "ParseError", ["DOCTYPE", "a", null, null, false]]}, + +{"description":"<!DOCTYPEa a/", +"input":"<!DOCTYPEa a/", +"output":["ParseError", "ParseError", ["DOCTYPE", "a", null, null, false]]}, + +{"description":"<!DOCTYPEa a0", +"input":"<!DOCTYPEa a0", +"output":["ParseError", "ParseError", ["DOCTYPE", "a", null, null, false]]}, + +{"description":"<!DOCTYPEa a1", +"input":"<!DOCTYPEa a1", +"output":["ParseError", "ParseError", ["DOCTYPE", "a", null, null, false]]}, + +{"description":"<!DOCTYPEa a9", +"input":"<!DOCTYPEa a9", +"output":["ParseError", "ParseError", ["DOCTYPE", "a", null, null, false]]}, + +{"description":"<!DOCTYPEa a<", +"input":"<!DOCTYPEa a<", +"output":["ParseError", "ParseError", ["DOCTYPE", "a", null, null, false]]}, + +{"description":"<!DOCTYPEa a=", +"input":"<!DOCTYPEa a=", +"output":["ParseError", "ParseError", ["DOCTYPE", "a", null, null, false]]}, + +{"description":"<!DOCTYPEa a>", +"input":"<!DOCTYPEa a>", +"output":["ParseError", "ParseError", ["DOCTYPE", "a", null, null, false]]}, + +{"description":"<!DOCTYPEa a?", +"input":"<!DOCTYPEa a?", +"output":["ParseError", "ParseError", ["DOCTYPE", "a", null, null, false]]}, + +{"description":"<!DOCTYPEa a@", +"input":"<!DOCTYPEa a@", +"output":["ParseError", "ParseError", ["DOCTYPE", "a", null, null, false]]}, + +{"description":"<!DOCTYPEa aA", +"input":"<!DOCTYPEa aA", +"output":["ParseError", "ParseError", ["DOCTYPE", "a", null, null, false]]}, + +{"description":"<!DOCTYPEa aB", +"input":"<!DOCTYPEa aB", +"output":["ParseError", "ParseError", ["DOCTYPE", "a", null, null, false]]}, + +{"description":"<!DOCTYPEa aY", +"input":"<!DOCTYPEa aY", +"output":["ParseError", "ParseError", ["DOCTYPE", "a", null, null, false]]}, + +{"description":"<!DOCTYPEa aZ", +"input":"<!DOCTYPEa aZ", +"output":["ParseError", "ParseError", ["DOCTYPE", "a", null, null, false]]}, + +{"description":"<!DOCTYPEa a`", +"input":"<!DOCTYPEa a`", +"output":["ParseError", "ParseError", ["DOCTYPE", "a", null, null, false]]}, + +{"description":"<!DOCTYPEa aa", +"input":"<!DOCTYPEa aa", +"output":["ParseError", "ParseError", ["DOCTYPE", "a", null, null, false]]}, + +{"description":"<!DOCTYPEa ab", +"input":"<!DOCTYPEa ab", +"output":["ParseError", "ParseError", ["DOCTYPE", "a", null, null, false]]}, + +{"description":"<!DOCTYPEa ay", +"input":"<!DOCTYPEa ay", +"output":["ParseError", "ParseError", ["DOCTYPE", "a", null, null, false]]}, + +{"description":"<!DOCTYPEa az", +"input":"<!DOCTYPEa az", +"output":["ParseError", "ParseError", ["DOCTYPE", "a", null, null, false]]}, + +{"description":"<!DOCTYPEa a{", +"input":"<!DOCTYPEa a{", +"output":["ParseError", "ParseError", ["DOCTYPE", "a", null, null, false]]}, + +{"description":"<!DOCTYPEa a\\uDBC0\\uDC00", +"input":"<!DOCTYPEa a\uDBC0\uDC00", +"output":["ParseError", "ParseError", ["DOCTYPE", "a", null, null, false]]}, + +{"description":"<!DOCTYPEa b", +"input":"<!DOCTYPEa b", +"output":["ParseError", "ParseError", ["DOCTYPE", "a", null, null, false]]}, + +{"description":"<!DOCTYPEa y", +"input":"<!DOCTYPEa y", +"output":["ParseError", "ParseError", ["DOCTYPE", "a", null, null, false]]}, + +{"description":"<!DOCTYPEa z", +"input":"<!DOCTYPEa z", +"output":["ParseError", "ParseError", ["DOCTYPE", "a", null, null, false]]}, + +{"description":"<!DOCTYPEa {", +"input":"<!DOCTYPEa {", +"output":["ParseError", "ParseError", ["DOCTYPE", "a", null, null, false]]}, + +{"description":"<!DOCTYPEa \\uDBC0\\uDC00", +"input":"<!DOCTYPEa \uDBC0\uDC00", +"output":["ParseError", "ParseError", ["DOCTYPE", "a", null, null, false]]}, + +{"description":"<!DOCTYPEa!", +"input":"<!DOCTYPEa!", +"output":["ParseError", "ParseError", ["DOCTYPE", "a!", null, null, false]]}, + +{"description":"<!DOCTYPEa\"", +"input":"<!DOCTYPEa\"", +"output":["ParseError", "ParseError", ["DOCTYPE", "a\"", null, null, false]]}, + +{"description":"<!DOCTYPEa&", +"input":"<!DOCTYPEa&", +"output":["ParseError", "ParseError", ["DOCTYPE", "a&", null, null, false]]}, + +{"description":"<!DOCTYPEa'", +"input":"<!DOCTYPEa'", +"output":["ParseError", "ParseError", ["DOCTYPE", "a'", null, null, false]]}, + +{"description":"<!DOCTYPEa-", +"input":"<!DOCTYPEa-", +"output":["ParseError", "ParseError", ["DOCTYPE", "a-", null, null, false]]}, + +{"description":"<!DOCTYPEa/", +"input":"<!DOCTYPEa/", +"output":["ParseError", "ParseError", ["DOCTYPE", "a/", null, null, false]]}, + +{"description":"<!DOCTYPEa0", +"input":"<!DOCTYPEa0", +"output":["ParseError", "ParseError", ["DOCTYPE", "a0", null, null, false]]}, + +{"description":"<!DOCTYPEa1", +"input":"<!DOCTYPEa1", +"output":["ParseError", "ParseError", ["DOCTYPE", "a1", null, null, false]]}, + +{"description":"<!DOCTYPEa9", +"input":"<!DOCTYPEa9", +"output":["ParseError", "ParseError", ["DOCTYPE", "a9", null, null, false]]}, + +{"description":"<!DOCTYPEa<", +"input":"<!DOCTYPEa<", +"output":["ParseError", "ParseError", ["DOCTYPE", "a<", null, null, false]]}, + +{"description":"<!DOCTYPEa=", +"input":"<!DOCTYPEa=", +"output":["ParseError", "ParseError", ["DOCTYPE", "a=", null, null, false]]}, + +{"description":"<!DOCTYPEa>", +"input":"<!DOCTYPEa>", +"output":["ParseError", ["DOCTYPE", "a", null, null, true]]}, + +{"description":"<!DOCTYPEa?", +"input":"<!DOCTYPEa?", +"output":["ParseError", "ParseError", ["DOCTYPE", "a?", null, null, false]]}, + +{"description":"<!DOCTYPEa@", +"input":"<!DOCTYPEa@", +"output":["ParseError", "ParseError", ["DOCTYPE", "a@", null, null, false]]}, + +{"description":"<!DOCTYPEaA", +"input":"<!DOCTYPEaA", +"output":["ParseError", "ParseError", ["DOCTYPE", "aa", null, null, false]]}, + +{"description":"<!DOCTYPEaB", +"input":"<!DOCTYPEaB", +"output":["ParseError", "ParseError", ["DOCTYPE", "ab", null, null, false]]}, + +{"description":"<!DOCTYPEaY", +"input":"<!DOCTYPEaY", +"output":["ParseError", "ParseError", ["DOCTYPE", "ay", null, null, false]]}, + +{"description":"<!DOCTYPEaZ", +"input":"<!DOCTYPEaZ", +"output":["ParseError", "ParseError", ["DOCTYPE", "az", null, null, false]]}, + +{"description":"<!DOCTYPEa[", +"input":"<!DOCTYPEa[", +"output":["ParseError", "ParseError", ["DOCTYPE", "a[", null, null, false]]}, + +{"description":"<!DOCTYPEa`", +"input":"<!DOCTYPEa`", +"output":["ParseError", "ParseError", ["DOCTYPE", "a`", null, null, false]]}, + +{"description":"<!DOCTYPEaa", +"input":"<!DOCTYPEaa", +"output":["ParseError", "ParseError", ["DOCTYPE", "aa", null, null, false]]}, + +{"description":"<!DOCTYPEab", +"input":"<!DOCTYPEab", +"output":["ParseError", "ParseError", ["DOCTYPE", "ab", null, null, false]]}, + +{"description":"<!DOCTYPEay", +"input":"<!DOCTYPEay", +"output":["ParseError", "ParseError", ["DOCTYPE", "ay", null, null, false]]}, + +{"description":"<!DOCTYPEaz", +"input":"<!DOCTYPEaz", +"output":["ParseError", "ParseError", ["DOCTYPE", "az", null, null, false]]}, + +{"description":"<!DOCTYPEa{", +"input":"<!DOCTYPEa{", +"output":["ParseError", "ParseError", ["DOCTYPE", "a{", null, null, false]]}, + +{"description":"<!DOCTYPEa\\uDBC0\\uDC00", +"input":"<!DOCTYPEa\uDBC0\uDC00", +"output":["ParseError", "ParseError", ["DOCTYPE", "a\uDBC0\uDC00", null, null, false]]}, + +{"description":"<!DOCTYPEb", +"input":"<!DOCTYPEb", +"output":["ParseError", "ParseError", ["DOCTYPE", "b", null, null, false]]}, + +{"description":"<!DOCTYPEy", +"input":"<!DOCTYPEy", +"output":["ParseError", "ParseError", ["DOCTYPE", "y", null, null, false]]}, + +{"description":"<!DOCTYPEz", +"input":"<!DOCTYPEz", +"output":["ParseError", "ParseError", ["DOCTYPE", "z", null, null, false]]}, + +{"description":"<!DOCTYPE{", +"input":"<!DOCTYPE{", +"output":["ParseError", "ParseError", ["DOCTYPE", "{", null, null, false]]}, + +{"description":"<!DOCTYPE\\uDBC0\\uDC00", +"input":"<!DOCTYPE\uDBC0\uDC00", +"output":["ParseError", "ParseError", ["DOCTYPE", "\uDBC0\uDC00", null, null, false]]}, + +{"description":"<!Y", +"input":"<!Y", +"output":["ParseError", ["Comment", "Y"]]}, + +{"description":"<!Z", +"input":"<!Z", +"output":["ParseError", ["Comment", "Z"]]}, + +{"description":"<!`", +"input":"<!`", +"output":["ParseError", ["Comment", "`"]]}, + +{"description":"<!a", +"input":"<!a", +"output":["ParseError", ["Comment", "a"]]}, + +{"description":"<!b", +"input":"<!b", +"output":["ParseError", ["Comment", "b"]]}, + +{"description":"<!y", +"input":"<!y", +"output":["ParseError", ["Comment", "y"]]}, + +{"description":"<!z", +"input":"<!z", +"output":["ParseError", ["Comment", "z"]]}, + +{"description":"<!{", +"input":"<!{", +"output":["ParseError", ["Comment", "{"]]}, + +{"description":"<!\\uDBC0\\uDC00", +"input":"<!\uDBC0\uDC00", +"output":["ParseError", ["Comment", "\uDBC0\uDC00"]]}, + +{"description":"<\"", +"input":"<\"", +"output":["ParseError", ["Character", "<\""]]}, + +{"description":"<&", +"input":"<&", +"output":["ParseError", ["Character", "<&"]]}, + +{"description":"<'", +"input":"<'", +"output":["ParseError", ["Character", "<'"]]}, + +{"description":"<-", +"input":"<-", +"output":["ParseError", ["Character", "<-"]]}, + +{"description":"<.", +"input":"<.", +"output":["ParseError", ["Character", "<."]]}, + +{"description":"</", +"input":"</", +"output":["ParseError", ["Character", "</"]]}, + +{"description":"</\\u0000", +"input":"</\u0000", +"output":["ParseError", ["Comment", "\uFFFD"]]}, + +{"description":"</\\u0009", +"input":"</\u0009", +"output":["ParseError", ["Comment", "\u0009"]]}, + +{"description":"</\\u000A", +"input":"</\u000A", +"output":["ParseError", ["Comment", "\u000A"]]}, + +{"description":"</\\u000B", +"input":"</\u000B", +"output":["ParseError", "ParseError", ["Comment", "\u000B"]]}, + +{"description":"</\\u000C", +"input":"</\u000C", +"output":["ParseError", ["Comment", "\u000C"]]}, + +{"description":"</ ", +"input":"</ ", +"output":["ParseError", ["Comment", " "]]}, + +{"description":"</!", +"input":"</!", +"output":["ParseError", ["Comment", "!"]]}, + +{"description":"</\"", +"input":"</\"", +"output":["ParseError", ["Comment", "\""]]}, + +{"description":"</&", +"input":"</&", +"output":["ParseError", ["Comment", "&"]]}, + +{"description":"</'", +"input":"</'", +"output":["ParseError", ["Comment", "'"]]}, + +{"description":"</-", +"input":"</-", +"output":["ParseError", ["Comment", "-"]]}, + +{"description":"<//", +"input":"<//", +"output":["ParseError", ["Comment", "/"]]}, + +{"description":"</0", +"input":"</0", +"output":["ParseError", ["Comment", "0"]]}, + +{"description":"</1", +"input":"</1", +"output":["ParseError", ["Comment", "1"]]}, + +{"description":"</9", +"input":"</9", +"output":["ParseError", ["Comment", "9"]]}, + +{"description":"</<", +"input":"</<", +"output":["ParseError", ["Comment", "<"]]}, + +{"description":"</=", +"input":"</=", +"output":["ParseError", ["Comment", "="]]}, + +{"description":"</>", +"input":"</>", +"output":["ParseError"]}, + +{"description":"</?", +"input":"</?", +"output":["ParseError", ["Comment", "?"]]}, + +{"description":"</@", +"input":"</@", +"output":["ParseError", ["Comment", "@"]]}, + +{"description":"</A>", +"input":"</A>", +"output":[["EndTag", "a"]]}, + +{"description":"</B>", +"input":"</B>", +"output":[["EndTag", "b"]]}, + +{"description":"</Y>", +"input":"</Y>", +"output":[["EndTag", "y"]]}, + +{"description":"</Z>", +"input":"</Z>", +"output":[["EndTag", "z"]]}, + +{"description":"</[", +"input":"</[", +"output":["ParseError", ["Comment", "["]]}, + +{"description":"</`", +"input":"</`", +"output":["ParseError", ["Comment", "`"]]}, + +{"description":"</a>", +"input":"</a>", +"output":[["EndTag", "a"]]}, + +{"description":"</b>", +"input":"</b>", +"output":[["EndTag", "b"]]}, + +{"description":"</y>", +"input":"</y>", +"output":[["EndTag", "y"]]}, + +{"description":"</z>", +"input":"</z>", +"output":[["EndTag", "z"]]}, + +{"description":"</{", +"input":"</{", +"output":["ParseError", ["Comment", "{"]]}, + +{"description":"</\\uDBC0\\uDC00", +"input":"</\uDBC0\uDC00", +"output":["ParseError", ["Comment", "\uDBC0\uDC00"]]}, + +{"description":"<0", +"input":"<0", +"output":["ParseError", ["Character", "<0"]]}, + +{"description":"<1", +"input":"<1", +"output":["ParseError", ["Character", "<1"]]}, + +{"description":"<9", +"input":"<9", +"output":["ParseError", ["Character", "<9"]]}, + +{"description":"<<", +"input":"<<", +"output":["ParseError", ["Character", "<"], "ParseError", ["Character", "<"]]}, + +{"description":"<=", +"input":"<=", +"output":["ParseError", ["Character", "<="]]}, + +{"description":"<>", +"input":"<>", +"output":["ParseError", ["Character", "<>"]]}, + +{"description":"<?", +"input":"<?", +"output":["ParseError", ["Comment", "?"]]}, + +{"description":"<?\\u0000", +"input":"<?\u0000", +"output":["ParseError", ["Comment", "?\uFFFD"]]}, + +{"description":"<?\\u0009", +"input":"<?\u0009", +"output":["ParseError", ["Comment", "?\u0009"]]}, + +{"description":"<?\\u000A", +"input":"<?\u000A", +"output":["ParseError", ["Comment", "?\u000A"]]}, + +{"description":"<?\\u000B", +"input":"<?\u000B", +"output":["ParseError", "ParseError", ["Comment", "?\u000B"]]}, + +{"description":"<?\\u000C", +"input":"<?\u000C", +"output":["ParseError", ["Comment", "?\u000C"]]}, + +{"description":"<? ", +"input":"<? ", +"output":["ParseError", ["Comment", "? "]]}, + +{"description":"<?!", +"input":"<?!", +"output":["ParseError", ["Comment", "?!"]]}, + +{"description":"<?\"", +"input":"<?\"", +"output":["ParseError", ["Comment", "?\""]]}, + +{"description":"<?&", +"input":"<?&", +"output":["ParseError", ["Comment", "?&"]]}, + +{"description":"<?'", +"input":"<?'", +"output":["ParseError", ["Comment", "?'"]]}, + +{"description":"<?-", +"input":"<?-", +"output":["ParseError", ["Comment", "?-"]]}, + +{"description":"<?/", +"input":"<?/", +"output":["ParseError", ["Comment", "?/"]]}, + +{"description":"<?0", +"input":"<?0", +"output":["ParseError", ["Comment", "?0"]]}, + +{"description":"<?1", +"input":"<?1", +"output":["ParseError", ["Comment", "?1"]]}, + +{"description":"<?9", +"input":"<?9", +"output":["ParseError", ["Comment", "?9"]]}, + +{"description":"<?<", +"input":"<?<", +"output":["ParseError", ["Comment", "?<"]]}, + +{"description":"<?=", +"input":"<?=", +"output":["ParseError", ["Comment", "?="]]}, + +{"description":"<?>", +"input":"<?>", +"output":["ParseError", ["Comment", "?"]]}, + +{"description":"<??", +"input":"<??", +"output":["ParseError", ["Comment", "??"]]}, + +{"description":"<?@", +"input":"<?@", +"output":["ParseError", ["Comment", "?@"]]}, + +{"description":"<?A", +"input":"<?A", +"output":["ParseError", ["Comment", "?A"]]}, + +{"description":"<?B", +"input":"<?B", +"output":["ParseError", ["Comment", "?B"]]}, + +{"description":"<?Y", +"input":"<?Y", +"output":["ParseError", ["Comment", "?Y"]]}, + +{"description":"<?Z", +"input":"<?Z", +"output":["ParseError", ["Comment", "?Z"]]}, + +{"description":"<?`", +"input":"<?`", +"output":["ParseError", ["Comment", "?`"]]}, + +{"description":"<?a", +"input":"<?a", +"output":["ParseError", ["Comment", "?a"]]}, + +{"description":"<?b", +"input":"<?b", +"output":["ParseError", ["Comment", "?b"]]}, + +{"description":"<?y", +"input":"<?y", +"output":["ParseError", ["Comment", "?y"]]}, + +{"description":"<?z", +"input":"<?z", +"output":["ParseError", ["Comment", "?z"]]}, + +{"description":"<?{", +"input":"<?{", +"output":["ParseError", ["Comment", "?{"]]}, + +{"description":"<?\\uDBC0\\uDC00", +"input":"<?\uDBC0\uDC00", +"output":["ParseError", ["Comment", "?\uDBC0\uDC00"]]}, + +{"description":"<@", +"input":"<@", +"output":["ParseError", ["Character", "<@"]]}, + +{"description":"<A>", +"input":"<A>", +"output":[["StartTag", "a", {}]]}, + +{"description":"<B>", +"input":"<B>", +"output":[["StartTag", "b", {}]]}, + +{"description":"<Y>", +"input":"<Y>", +"output":[["StartTag", "y", {}]]}, + +{"description":"<Z>", +"input":"<Z>", +"output":[["StartTag", "z", {}]]}, + +{"description":"<[", +"input":"<[", +"output":["ParseError", ["Character", "<["]]}, + +{"description":"<`", +"input":"<`", +"output":["ParseError", ["Character", "<`"]]}, + +{"description":"<a>", +"input":"<a>", +"output":[["StartTag", "a", {}]]}, + +{"description":"<a\\u0000>", +"input":"<a\u0000>", +"output":["ParseError", ["StartTag", "a\uFFFD", {}]]}, + +{"description":"<a\\u0008>", +"input":"<a\u0008>", +"output":["ParseError", ["StartTag", "a\u0008", {}]]}, + +{"description":"<a\\u0009>", +"input":"<a\u0009>", +"output":[["StartTag", "a", {}]]}, + +{"description":"<a\\u000A>", +"input":"<a\u000A>", +"output":[["StartTag", "a", {}]]}, + +{"description":"<a\\u000B>", +"input":"<a\u000B>", +"output":["ParseError", ["StartTag", "a\u000B", {}]]}, + +{"description":"<a\\u000C>", +"input":"<a\u000C>", +"output":[["StartTag", "a", {}]]}, + +{"description":"<a\\u000D>", +"input":"<a\u000D>", +"output":[["StartTag", "a", {}]]}, + +{"description":"<a\\u001F>", +"input":"<a\u001F>", +"output":["ParseError", ["StartTag", "a\u001F", {}]]}, + +{"description":"<a >", +"input":"<a >", +"output":[["StartTag", "a", {}]]}, + +{"description":"<a \\u0000>", +"input":"<a \u0000>", +"output":["ParseError", ["StartTag", "a", {"\uFFFD":""}]]}, + +{"description":"<a \\u0008>", +"input":"<a \u0008>", +"output":["ParseError", ["StartTag", "a", {"\u0008":""}]]}, + +{"description":"<a \\u0009>", +"input":"<a \u0009>", +"output":[["StartTag", "a", {}]]}, + +{"description":"<a \\u000A>", +"input":"<a \u000A>", +"output":[["StartTag", "a", {}]]}, + +{"description":"<a \\u000B>", +"input":"<a \u000B>", +"output":["ParseError", ["StartTag", "a", {"\u000B":""}]]}, + +{"description":"<a \\u000C>", +"input":"<a \u000C>", +"output":[["StartTag", "a", {}]]}, + +{"description":"<a \\u000D>", +"input":"<a \u000D>", +"output":[["StartTag", "a", {}]]}, + +{"description":"<a \\u001F>", +"input":"<a \u001F>", +"output":["ParseError", ["StartTag", "a", {"\u001F":""}]]}, + +{"description":"<a >", +"input":"<a >", +"output":[["StartTag", "a", {}]]}, + +{"description":"<a !>", +"input":"<a !>", +"output":[["StartTag", "a", {"!":""}]]}, + +{"description":"<a \">", +"input":"<a \">", +"output":["ParseError", ["StartTag", "a", {"\"":""}]]}, + +{"description":"<a #>", +"input":"<a #>", +"output":[["StartTag", "a", {"#":""}]]}, + +{"description":"<a &>", +"input":"<a &>", +"output":[["StartTag", "a", {"&":""}]]}, + +{"description":"<a '>", +"input":"<a '>", +"output":["ParseError", ["StartTag", "a", {"'":""}]]}, + +{"description":"<a (>", +"input":"<a (>", +"output":[["StartTag", "a", {"(":""}]]}, + +{"description":"<a ->", +"input":"<a ->", +"output":[["StartTag", "a", {"-":""}]]}, + +{"description":"<a .>", +"input":"<a .>", +"output":[["StartTag", "a", {".":""}]]}, + +{"description":"<a />", +"input":"<a />", +"output":[["StartTag", "a", {}, true]]}, + +{"description":"<a 0>", +"input":"<a 0>", +"output":[["StartTag", "a", {"0":""}]]}, + +{"description":"<a 1>", +"input":"<a 1>", +"output":[["StartTag", "a", {"1":""}]]}, + +{"description":"<a 9>", +"input":"<a 9>", +"output":[["StartTag", "a", {"9":""}]]}, + +{"description":"<a <>", +"input":"<a <>", +"output":["ParseError", ["StartTag", "a", {"<":""}]]}, + +{"description":"<a =>", +"input":"<a =>", +"output":["ParseError", ["StartTag", "a", {"=":""}]]}, + +{"description":"<a >", +"input":"<a >", +"output":[["StartTag", "a", {}]]}, + +{"description":"<a ?>", +"input":"<a ?>", +"output":[["StartTag", "a", {"?":""}]]}, + +{"description":"<a @>", +"input":"<a @>", +"output":[["StartTag", "a", {"@":""}]]}, + +{"description":"<a A>", +"input":"<a A>", +"output":[["StartTag", "a", {"a":""}]]}, + +{"description":"<a B>", +"input":"<a B>", +"output":[["StartTag", "a", {"b":""}]]}, + +{"description":"<a Y>", +"input":"<a Y>", +"output":[["StartTag", "a", {"y":""}]]}, + +{"description":"<a Z>", +"input":"<a Z>", +"output":[["StartTag", "a", {"z":""}]]}, + +{"description":"<a [>", +"input":"<a [>", +"output":[["StartTag", "a", {"[":""}]]}, + +{"description":"<a `>", +"input":"<a `>", +"output":[["StartTag", "a", {"`":""}]]}, + +{"description":"<a a>", +"input":"<a a>", +"output":[["StartTag", "a", {"a":""}]]}, + +{"description":"<a a\\u0000>", +"input":"<a a\u0000>", +"output":["ParseError", ["StartTag", "a", {"a\uFFFD":""}]]}, + +{"description":"<a a\\u0008>", +"input":"<a a\u0008>", +"output":["ParseError", ["StartTag", "a", {"a\u0008":""}]]}, + +{"description":"<a a\\u0009>", +"input":"<a a\u0009>", +"output":[["StartTag", "a", {"a":""}]]}, + +{"description":"<a a\\u000A>", +"input":"<a a\u000A>", +"output":[["StartTag", "a", {"a":""}]]}, + +{"description":"<a a\\u000B>", +"input":"<a a\u000B>", +"output":["ParseError", ["StartTag", "a", {"a\u000B":""}]]}, + +{"description":"<a a\\u000C>", +"input":"<a a\u000C>", +"output":[["StartTag", "a", {"a":""}]]}, + +{"description":"<a a\\u000D>", +"input":"<a a\u000D>", +"output":[["StartTag", "a", {"a":""}]]}, + +{"description":"<a a\\u001F>", +"input":"<a a\u001F>", +"output":["ParseError", ["StartTag", "a", {"a\u001F":""}]]}, + +{"description":"<a a >", +"input":"<a a >", +"output":[["StartTag", "a", {"a":""}]]}, + +{"description":"<a a \\u0000>", +"input":"<a a \u0000>", +"output":["ParseError", ["StartTag", "a", {"a":"", "\uFFFD":""}]]}, + +{"description":"<a a \\u0008>", +"input":"<a a \u0008>", +"output":["ParseError", ["StartTag", "a", {"a":"", "\u0008":""}]]}, + +{"description":"<a a \\u0009>", +"input":"<a a \u0009>", +"output":[["StartTag", "a", {"a":""}]]}, + +{"description":"<a a \\u000A>", +"input":"<a a \u000A>", +"output":[["StartTag", "a", {"a":""}]]}, + +{"description":"<a a \\u000B>", +"input":"<a a \u000B>", +"output":["ParseError", ["StartTag", "a", {"a":"", "\u000B":""}]]}, + +{"description":"<a a \\u000C>", +"input":"<a a \u000C>", +"output":[["StartTag", "a", {"a":""}]]}, + +{"description":"<a a \\u000D>", +"input":"<a a \u000D>", +"output":[["StartTag", "a", {"a":""}]]}, + +{"description":"<a a \\u001F>", +"input":"<a a \u001F>", +"output":["ParseError", ["StartTag", "a", {"a":"", "\u001F":""}]]}, + +{"description":"<a a >", +"input":"<a a >", +"output":[["StartTag", "a", {"a":""}]]}, + +{"description":"<a a !>", +"input":"<a a !>", +"output":[["StartTag", "a", {"a":"", "!":""}]]}, + +{"description":"<a a \">", +"input":"<a a \">", +"output":["ParseError", ["StartTag", "a", {"a":"", "\"":""}]]}, + +{"description":"<a a #>", +"input":"<a a #>", +"output":[["StartTag", "a", {"a":"", "#":""}]]}, + +{"description":"<a a &>", +"input":"<a a &>", +"output":[["StartTag", "a", {"a":"", "&":""}]]}, + +{"description":"<a a '>", +"input":"<a a '>", +"output":["ParseError", ["StartTag", "a", {"a":"", "'":""}]]}, + +{"description":"<a a (>", +"input":"<a a (>", +"output":[["StartTag", "a", {"a":"", "(":""}]]}, + +{"description":"<a a ->", +"input":"<a a ->", +"output":[["StartTag", "a", {"a":"", "-":""}]]}, + +{"description":"<a a .>", +"input":"<a a .>", +"output":[["StartTag", "a", {"a":"", ".":""}]]}, + +{"description":"<a a />", +"input":"<a a />", +"output":[["StartTag", "a", {"a":""}, true]]}, + +{"description":"<a a 0>", +"input":"<a a 0>", +"output":[["StartTag", "a", {"a":"", "0":""}]]}, + +{"description":"<a a 1>", +"input":"<a a 1>", +"output":[["StartTag", "a", {"a":"", "1":""}]]}, + +{"description":"<a a 9>", +"input":"<a a 9>", +"output":[["StartTag", "a", {"a":"", "9":""}]]}, + +{"description":"<a a <>", +"input":"<a a <>", +"output":["ParseError", ["StartTag", "a", {"a":"", "<":""}]]}, + +{"description":"<a a =>", +"input":"<a a =>", +"output":["ParseError", ["StartTag", "a", {"a":""}]]}, + +{"description":"<a a >", +"input":"<a a >", +"output":[["StartTag", "a", {"a":""}]]}, + +{"description":"<a a ?>", +"input":"<a a ?>", +"output":[["StartTag", "a", {"a":"", "?":""}]]}, + +{"description":"<a a @>", +"input":"<a a @>", +"output":[["StartTag", "a", {"a":"", "@":""}]]}, + +{"description":"<a a A>", +"input":"<a a A>", +"output":["ParseError", ["StartTag", "a", {"a":""}]]}, + +{"description":"<a a B>", +"input":"<a a B>", +"output":[["StartTag", "a", {"a":"", "b":""}]]}, + +{"description":"<a a Y>", +"input":"<a a Y>", +"output":[["StartTag", "a", {"a":"", "y":""}]]}, + +{"description":"<a a Z>", +"input":"<a a Z>", +"output":[["StartTag", "a", {"a":"", "z":""}]]}, + +{"description":"<a a [>", +"input":"<a a [>", +"output":[["StartTag", "a", {"a":"", "[":""}]]}, + +{"description":"<a a `>", +"input":"<a a `>", +"output":[["StartTag", "a", {"a":"", "`":""}]]}, + +{"description":"<a a a>", +"input":"<a a a>", +"output":["ParseError", ["StartTag", "a", {"a":""}]]}, + +{"description":"<a a b>", +"input":"<a a b>", +"output":[["StartTag", "a", {"a":"", "b":""}]]}, + +{"description":"<a a y>", +"input":"<a a y>", +"output":[["StartTag", "a", {"a":"", "y":""}]]}, + +{"description":"<a a z>", +"input":"<a a z>", +"output":[["StartTag", "a", {"a":"", "z":""}]]}, + +{"description":"<a a {>", +"input":"<a a {>", +"output":[["StartTag", "a", {"a":"", "{":""}]]}, + +{"description":"<a a \\uDBC0\\uDC00>", +"input":"<a a \uDBC0\uDC00>", +"output":[["StartTag", "a", {"a":"", "\uDBC0\uDC00":""}]]}, + +{"description":"<a a!>", +"input":"<a a!>", +"output":[["StartTag", "a", {"a!":""}]]}, + +{"description":"<a a\">", +"input":"<a a\">", +"output":["ParseError", ["StartTag", "a", {"a\"":""}]]}, + +{"description":"<a a#>", +"input":"<a a#>", +"output":[["StartTag", "a", {"a#":""}]]}, + +{"description":"<a a&>", +"input":"<a a&>", +"output":[["StartTag", "a", {"a&":""}]]}, + +{"description":"<a a'>", +"input":"<a a'>", +"output":["ParseError", ["StartTag", "a", {"a'":""}]]}, + +{"description":"<a a(>", +"input":"<a a(>", +"output":[["StartTag", "a", {"a(":""}]]}, + +{"description":"<a a->", +"input":"<a a->", +"output":[["StartTag", "a", {"a-":""}]]}, + +{"description":"<a a.>", +"input":"<a a.>", +"output":[["StartTag", "a", {"a.":""}]]}, + +{"description":"<a a/>", +"input":"<a a/>", +"output":[["StartTag", "a", {"a":""}, true]]}, + +{"description":"<a a0>", +"input":"<a a0>", +"output":[["StartTag", "a", {"a0":""}]]}, + +{"description":"<a a1>", +"input":"<a a1>", +"output":[["StartTag", "a", {"a1":""}]]}, + +{"description":"<a a9>", +"input":"<a a9>", +"output":[["StartTag", "a", {"a9":""}]]}, + +{"description":"<a a<>", +"input":"<a a<>", +"output":["ParseError", ["StartTag", "a", {"a<":""}]]}, + +{"description":"<a a=>", +"input":"<a a=>", +"output":["ParseError", ["StartTag", "a", {"a":""}]]}, + +{"description":"<a a=\\u0000>", +"input":"<a a=\u0000>", +"output":["ParseError", ["StartTag", "a", {"a":"\uFFFD"}]]}, + +{"description":"<a a=\\u0008>", +"input":"<a a=\u0008>", +"output":["ParseError", ["StartTag", "a", {"a":"\u0008"}]]}, + +{"description":"<a a=\\u0009>", +"input":"<a a=\u0009>", +"output":["ParseError", ["StartTag", "a", {"a":""}]]}, + +{"description":"<a a=\\u000A>", +"input":"<a a=\u000A>", +"output":["ParseError", ["StartTag", "a", {"a":""}]]}, + +{"description":"<a a=\\u000B>", +"input":"<a a=\u000B>", +"output":["ParseError", ["StartTag", "a", {"a":"\u000B"}]]}, + +{"description":"<a a=\\u000C>", +"input":"<a a=\u000C>", +"output":["ParseError", ["StartTag", "a", {"a":""}]]}, + +{"description":"<a a=\\u000D>", +"input":"<a a=\u000D>", +"output":["ParseError", ["StartTag", "a", {"a":""}]]}, + +{"description":"<a a=\\u001F>", +"input":"<a a=\u001F>", +"output":["ParseError", ["StartTag", "a", {"a":"\u001F"}]]}, + +{"description":"<a a= >", +"input":"<a a= >", +"output":["ParseError", ["StartTag", "a", {"a":""}]]}, + +{"description":"<a a=!>", +"input":"<a a=!>", +"output":[["StartTag", "a", {"a":"!"}]]}, + +{"description":"<a a=\"\">", +"input":"<a a=\"\">", +"output":[["StartTag", "a", {"a":""}]]}, + +{"description":"<a a=\"\\u0000\">", +"input":"<a a=\"\u0000\">", +"output":["ParseError", ["StartTag", "a", {"a":"\uFFFD"}]]}, + +{"description":"<a a=\"\\u0009\">", +"input":"<a a=\"\u0009\">", +"output":[["StartTag", "a", {"a":"\u0009"}]]}, + +{"description":"<a a=\"\\u000A\">", +"input":"<a a=\"\u000A\">", +"output":[["StartTag", "a", {"a":"\u000A"}]]}, + +{"description":"<a a=\"\\u000B\">", +"input":"<a a=\"\u000B\">", +"output":["ParseError", ["StartTag", "a", {"a":"\u000B"}]]}, + +{"description":"<a a=\"\\u000C\">", +"input":"<a a=\"\u000C\">", +"output":[["StartTag", "a", {"a":"\u000C"}]]}, + +{"description":"<a a=\" \">", +"input":"<a a=\" \">", +"output":[["StartTag", "a", {"a":" "}]]}, + +{"description":"<a a=\"!\">", +"input":"<a a=\"!\">", +"output":[["StartTag", "a", {"a":"!"}]]}, + +{"description":"<a a=\"\">", +"input":"<a a=\"\">", +"output":[["StartTag", "a", {"a":""}]]}, + +{"description":"<a a=\"#\">", +"input":"<a a=\"#\">", +"output":[["StartTag", "a", {"a":"#"}]]}, + +{"description":"<a a=\"%\">", +"input":"<a a=\"%\">", +"output":[["StartTag", "a", {"a":"%"}]]}, + +{"description":"<a a=\"&\">", +"input":"<a a=\"&\">", +"output":[["StartTag", "a", {"a":"&"}]]}, + +{"description":"<a a=\"'\">", +"input":"<a a=\"'\">", +"output":[["StartTag", "a", {"a":"'"}]]}, + +{"description":"<a a=\"-\">", +"input":"<a a=\"-\">", +"output":[["StartTag", "a", {"a":"-"}]]}, + +{"description":"<a a=\"/\">", +"input":"<a a=\"/\">", +"output":[["StartTag", "a", {"a":"/"}]]}, + +{"description":"<a a=\"0\">", +"input":"<a a=\"0\">", +"output":[["StartTag", "a", {"a":"0"}]]}, + +{"description":"<a a=\"1\">", +"input":"<a a=\"1\">", +"output":[["StartTag", "a", {"a":"1"}]]}, + +{"description":"<a a=\"9\">", +"input":"<a a=\"9\">", +"output":[["StartTag", "a", {"a":"9"}]]}, + +{"description":"<a a=\"<\">", +"input":"<a a=\"<\">", +"output":[["StartTag", "a", {"a":"<"}]]}, + +{"description":"<a a=\"=\">", +"input":"<a a=\"=\">", +"output":[["StartTag", "a", {"a":"="}]]}, + +{"description":"<a a=\">\">", +"input":"<a a=\">\">", +"output":[["StartTag", "a", {"a":">"}]]}, + +{"description":"<a a=\"?\">", +"input":"<a a=\"?\">", +"output":[["StartTag", "a", {"a":"?"}]]}, + +{"description":"<a a=\"@\">", +"input":"<a a=\"@\">", +"output":[["StartTag", "a", {"a":"@"}]]}, + +{"description":"<a a=\"A\">", +"input":"<a a=\"A\">", +"output":[["StartTag", "a", {"a":"A"}]]}, + +{"description":"<a a=\"B\">", +"input":"<a a=\"B\">", +"output":[["StartTag", "a", {"a":"B"}]]}, + +{"description":"<a a=\"Y\">", +"input":"<a a=\"Y\">", +"output":[["StartTag", "a", {"a":"Y"}]]}, + +{"description":"<a a=\"Z\">", +"input":"<a a=\"Z\">", +"output":[["StartTag", "a", {"a":"Z"}]]}, + +{"description":"<a a=\"`\">", +"input":"<a a=\"`\">", +"output":[["StartTag", "a", {"a":"`"}]]}, + +{"description":"<a a=\"a\">", +"input":"<a a=\"a\">", +"output":[["StartTag", "a", {"a":"a"}]]}, + +{"description":"<a a=\"b\">", +"input":"<a a=\"b\">", +"output":[["StartTag", "a", {"a":"b"}]]}, + +{"description":"<a a=\"y\">", +"input":"<a a=\"y\">", +"output":[["StartTag", "a", {"a":"y"}]]}, + +{"description":"<a a=\"z\">", +"input":"<a a=\"z\">", +"output":[["StartTag", "a", {"a":"z"}]]}, + +{"description":"<a a=\"{\">", +"input":"<a a=\"{\">", +"output":[["StartTag", "a", {"a":"{"}]]}, + +{"description":"<a a=\"\\uDBC0\\uDC00\">", +"input":"<a a=\"\uDBC0\uDC00\">", +"output":[["StartTag", "a", {"a":"\uDBC0\uDC00"}]]}, + +{"description":"<a a=#>", +"input":"<a a=#>", +"output":[["StartTag", "a", {"a":"#"}]]}, + +{"description":"<a a=%>", +"input":"<a a=%>", +"output":[["StartTag", "a", {"a":"%"}]]}, + +{"description":"<a a=&>", +"input":"<a a=&>", +"output":[["StartTag", "a", {"a":"&"}]]}, + +{"description":"<a a=''>", +"input":"<a a=''>", +"output":[["StartTag", "a", {"a":""}]]}, + +{"description":"<a a='\\u0000'>", +"input":"<a a='\u0000'>", +"output":["ParseError", ["StartTag", "a", {"a":"\uFFFD"}]]}, + +{"description":"<a a='\\u0009'>", +"input":"<a a='\u0009'>", +"output":[["StartTag", "a", {"a":"\u0009"}]]}, + +{"description":"<a a='\\u000A'>", +"input":"<a a='\u000A'>", +"output":[["StartTag", "a", {"a":"\u000A"}]]}, + +{"description":"<a a='\\u000B'>", +"input":"<a a='\u000B'>", +"output":["ParseError", ["StartTag", "a", {"a":"\u000B"}]]}, + +{"description":"<a a='\\u000C'>", +"input":"<a a='\u000C'>", +"output":[["StartTag", "a", {"a":"\u000C"}]]}, + +{"description":"<a a=' '>", +"input":"<a a=' '>", +"output":[["StartTag", "a", {"a":" "}]]}, + +{"description":"<a a='!'>", +"input":"<a a='!'>", +"output":[["StartTag", "a", {"a":"!"}]]}, + +{"description":"<a a='\"'>", +"input":"<a a='\"'>", +"output":[["StartTag", "a", {"a":"\""}]]}, + +{"description":"<a a='%'>", +"input":"<a a='%'>", +"output":[["StartTag", "a", {"a":"%"}]]}, + +{"description":"<a a='&'>", +"input":"<a a='&'>", +"output":[["StartTag", "a", {"a":"&"}]]}, + +{"description":"<a a=''>", +"input":"<a a=''>", +"output":[["StartTag", "a", {"a":""}]]}, + +{"description":"<a a=''\\u0000>", +"input":"<a a=''\u0000>", +"output":["ParseError", "ParseError", ["StartTag", "a", {"a":"", "\uFFFD":""}]]}, + +{"description":"<a a=''\\u0008>", +"input":"<a a=''\u0008>", +"output":["ParseError", "ParseError", ["StartTag", "a", {"a":"", "\u0008":""}]]}, + +{"description":"<a a=''\\u0009>", +"input":"<a a=''\u0009>", +"output":[["StartTag", "a", {"a":""}]]}, + +{"description":"<a a=''\\u000A>", +"input":"<a a=''\u000A>", +"output":[["StartTag", "a", {"a":""}]]}, + +{"description":"<a a=''\\u000B>", +"input":"<a a=''\u000B>", +"output":["ParseError", "ParseError", ["StartTag", "a", {"a":"", "\u000B":""}]]}, + +{"description":"<a a=''\\u000C>", +"input":"<a a=''\u000C>", +"output":[["StartTag", "a", {"a":""}]]}, + +{"description":"<a a=''\\u000D>", +"input":"<a a=''\u000D>", +"output":[["StartTag", "a", {"a":""}]]}, + +{"description":"<a a=''\\u001F>", +"input":"<a a=''\u001F>", +"output":["ParseError", "ParseError", ["StartTag", "a", {"a":"", "\u001F":""}]]}, + +{"description":"<a a='' >", +"input":"<a a='' >", +"output":[["StartTag", "a", {"a":""}]]}, + +{"description":"<a a=''!>", +"input":"<a a=''!>", +"output":["ParseError", ["StartTag", "a", {"a":"", "!":""}]]}, + +{"description":"<a a=''\">", +"input":"<a a=''\">", +"output":["ParseError", "ParseError", ["StartTag", "a", {"a":"", "\"":""}]]}, + +{"description":"<a a=''&>", +"input":"<a a=''&>", +"output":["ParseError", ["StartTag", "a", {"a":"", "&":""}]]}, + +{"description":"<a a='''>", +"input":"<a a='''>", +"output":["ParseError", "ParseError", ["StartTag", "a", {"a":"", "'":""}]]}, + +{"description":"<a a=''->", +"input":"<a a=''->", +"output":["ParseError", ["StartTag", "a", {"a":"", "-":""}]]}, + +{"description":"<a a=''.>", +"input":"<a a=''.>", +"output":["ParseError", ["StartTag", "a", {"a":"", ".":""}]]}, + +{"description":"<a a=''/>", +"input":"<a a=''/>", +"output":[["StartTag", "a", {"a":""}, true]]}, + +{"description":"<a a=''0>", +"input":"<a a=''0>", +"output":["ParseError", ["StartTag", "a", {"a":"", "0":""}]]}, + +{"description":"<a a=''1>", +"input":"<a a=''1>", +"output":["ParseError", ["StartTag", "a", {"a":"", "1":""}]]}, + +{"description":"<a a=''9>", +"input":"<a a=''9>", +"output":["ParseError", ["StartTag", "a", {"a":"", "9":""}]]}, + +{"description":"<a a=''<>", +"input":"<a a=''<>", +"output":["ParseError", "ParseError", ["StartTag", "a", {"a":"", "<":""}]]}, + +{"description":"<a a=''=>", +"input":"<a a=''=>", +"output":["ParseError", "ParseError", ["StartTag", "a", {"a":"", "=":""}]]}, + +{"description":"<a a=''>", +"input":"<a a=''>", +"output":[["StartTag", "a", {"a":""}]]}, + +{"description":"<a a=''?>", +"input":"<a a=''?>", +"output":["ParseError", ["StartTag", "a", {"a":"", "?":""}]]}, + +{"description":"<a a=''@>", +"input":"<a a=''@>", +"output":["ParseError", ["StartTag", "a", {"a":"", "@":""}]]}, + +{"description":"<a a=''A>", +"input":"<a a=''A>", +"output":["ParseError", "ParseError", ["StartTag", "a", {"a":""}]]}, + +{"description":"<a a=''B>", +"input":"<a a=''B>", +"output":["ParseError", ["StartTag", "a", {"a":"", "b":""}]]}, + +{"description":"<a a=''Y>", +"input":"<a a=''Y>", +"output":["ParseError", ["StartTag", "a", {"a":"", "y":""}]]}, + +{"description":"<a a=''Z>", +"input":"<a a=''Z>", +"output":["ParseError", ["StartTag", "a", {"a":"", "z":""}]]}, + +{"description":"<a a=''`>", +"input":"<a a=''`>", +"output":["ParseError", ["StartTag", "a", {"a":"", "`":""}]]}, + +{"description":"<a a=''a>", +"input":"<a a=''a>", +"output":["ParseError", "ParseError", ["StartTag", "a", {"a":""}]]}, + +{"description":"<a a=''b>", +"input":"<a a=''b>", +"output":["ParseError", ["StartTag", "a", {"a":"", "b":""}]]}, + +{"description":"<a a=''y>", +"input":"<a a=''y>", +"output":["ParseError", ["StartTag", "a", {"a":"", "y":""}]]}, + +{"description":"<a a=''z>", +"input":"<a a=''z>", +"output":["ParseError", ["StartTag", "a", {"a":"", "z":""}]]}, + +{"description":"<a a=''{>", +"input":"<a a=''{>", +"output":["ParseError", ["StartTag", "a", {"a":"", "{":""}]]}, + +{"description":"<a a=''\\uDBC0\\uDC00>", +"input":"<a a=''\uDBC0\uDC00>", +"output":["ParseError", ["StartTag", "a", {"a":"", "\uDBC0\uDC00":""}]]}, + +{"description":"<a a='('>", +"input":"<a a='('>", +"output":[["StartTag", "a", {"a":"("}]]}, + +{"description":"<a a='-'>", +"input":"<a a='-'>", +"output":[["StartTag", "a", {"a":"-"}]]}, + +{"description":"<a a='/'>", +"input":"<a a='/'>", +"output":[["StartTag", "a", {"a":"/"}]]}, + +{"description":"<a a='0'>", +"input":"<a a='0'>", +"output":[["StartTag", "a", {"a":"0"}]]}, + +{"description":"<a a='1'>", +"input":"<a a='1'>", +"output":[["StartTag", "a", {"a":"1"}]]}, + +{"description":"<a a='9'>", +"input":"<a a='9'>", +"output":[["StartTag", "a", {"a":"9"}]]}, + +{"description":"<a a='<'>", +"input":"<a a='<'>", +"output":[["StartTag", "a", {"a":"<"}]]}, + +{"description":"<a a='='>", +"input":"<a a='='>", +"output":[["StartTag", "a", {"a":"="}]]}, + +{"description":"<a a='>'>", +"input":"<a a='>'>", +"output":[["StartTag", "a", {"a":">"}]]}, + +{"description":"<a a='?'>", +"input":"<a a='?'>", +"output":[["StartTag", "a", {"a":"?"}]]}, + +{"description":"<a a='@'>", +"input":"<a a='@'>", +"output":[["StartTag", "a", {"a":"@"}]]}, + +{"description":"<a a='A'>", +"input":"<a a='A'>", +"output":[["StartTag", "a", {"a":"A"}]]}, + +{"description":"<a a='B'>", +"input":"<a a='B'>", +"output":[["StartTag", "a", {"a":"B"}]]}, + +{"description":"<a a='Y'>", +"input":"<a a='Y'>", +"output":[["StartTag", "a", {"a":"Y"}]]}, + +{"description":"<a a='Z'>", +"input":"<a a='Z'>", +"output":[["StartTag", "a", {"a":"Z"}]]}, + +{"description":"<a a='`'>", +"input":"<a a='`'>", +"output":[["StartTag", "a", {"a":"`"}]]}, + +{"description":"<a a='a'>", +"input":"<a a='a'>", +"output":[["StartTag", "a", {"a":"a"}]]}, + +{"description":"<a a='b'>", +"input":"<a a='b'>", +"output":[["StartTag", "a", {"a":"b"}]]}, + +{"description":"<a a='y'>", +"input":"<a a='y'>", +"output":[["StartTag", "a", {"a":"y"}]]}, + +{"description":"<a a='z'>", +"input":"<a a='z'>", +"output":[["StartTag", "a", {"a":"z"}]]}, + +{"description":"<a a='{'>", +"input":"<a a='{'>", +"output":[["StartTag", "a", {"a":"{"}]]}, + +{"description":"<a a='\\uDBC0\\uDC00'>", +"input":"<a a='\uDBC0\uDC00'>", +"output":[["StartTag", "a", {"a":"\uDBC0\uDC00"}]]}, + +{"description":"<a a=(>", +"input":"<a a=(>", +"output":[["StartTag", "a", {"a":"("}]]}, + +{"description":"<a a=->", +"input":"<a a=->", +"output":[["StartTag", "a", {"a":"-"}]]}, + +{"description":"<a a=/>", +"input":"<a a=/>", +"output":[["StartTag", "a", {"a":"/"}]]}, + +{"description":"<a a=0>", +"input":"<a a=0>", +"output":[["StartTag", "a", {"a":"0"}]]}, + +{"description":"<a a=1>", +"input":"<a a=1>", +"output":[["StartTag", "a", {"a":"1"}]]}, + +{"description":"<a a=9>", +"input":"<a a=9>", +"output":[["StartTag", "a", {"a":"9"}]]}, + +{"description":"<a a=<>", +"input":"<a a=<>", +"output":["ParseError", ["StartTag", "a", {"a":"<"}]]}, + +{"description":"<a a==>", +"input":"<a a==>", +"output":["ParseError", ["StartTag", "a", {"a":"="}]]}, + +{"description":"<a a=>", +"input":"<a a=>", +"output":["ParseError", ["StartTag", "a", {"a":""}]]}, + +{"description":"<a a=?>", +"input":"<a a=?>", +"output":[["StartTag", "a", {"a":"?"}]]}, + +{"description":"<a a=@>", +"input":"<a a=@>", +"output":[["StartTag", "a", {"a":"@"}]]}, + +{"description":"<a a=A>", +"input":"<a a=A>", +"output":[["StartTag", "a", {"a":"A"}]]}, + +{"description":"<a a=B>", +"input":"<a a=B>", +"output":[["StartTag", "a", {"a":"B"}]]}, + +{"description":"<a a=Y>", +"input":"<a a=Y>", +"output":[["StartTag", "a", {"a":"Y"}]]}, + +{"description":"<a a=Z>", +"input":"<a a=Z>", +"output":[["StartTag", "a", {"a":"Z"}]]}, + +{"description":"<a a=`>", +"input":"<a a=`>", +"output":["ParseError", ["StartTag", "a", {"a":"`"}]]}, + +{"description":"<a a=a>", +"input":"<a a=a>", +"output":[["StartTag", "a", {"a":"a"}]]}, + +{"description":"<a a=a\\u0000>", +"input":"<a a=a\u0000>", +"output":["ParseError", ["StartTag", "a", {"a":"a\uFFFD"}]]}, + +{"description":"<a a=a\\u0008>", +"input":"<a a=a\u0008>", +"output":["ParseError", ["StartTag", "a", {"a":"a\u0008"}]]}, + +{"description":"<a a=a\\u0009>", +"input":"<a a=a\u0009>", +"output":[["StartTag", "a", {"a":"a"}]]}, + +{"description":"<a a=a\\u000A>", +"input":"<a a=a\u000A>", +"output":[["StartTag", "a", {"a":"a"}]]}, + +{"description":"<a a=a\\u000B>", +"input":"<a a=a\u000B>", +"output":["ParseError", ["StartTag", "a", {"a":"a\u000B"}]]}, + +{"description":"<a a=a\\u000C>", +"input":"<a a=a\u000C>", +"output":[["StartTag", "a", {"a":"a"}]]}, + +{"description":"<a a=a\\u000D>", +"input":"<a a=a\u000D>", +"output":[["StartTag", "a", {"a":"a"}]]}, + +{"description":"<a a=a\\u001F>", +"input":"<a a=a\u001F>", +"output":["ParseError", ["StartTag", "a", {"a":"a\u001F"}]]}, + +{"description":"<a a=a >", +"input":"<a a=a >", +"output":[["StartTag", "a", {"a":"a"}]]}, + +{"description":"<a a=a!>", +"input":"<a a=a!>", +"output":[["StartTag", "a", {"a":"a!"}]]}, + +{"description":"<a a=a\">", +"input":"<a a=a\">", +"output":["ParseError", ["StartTag", "a", {"a":"a\""}]]}, + +{"description":"<a a=a#>", +"input":"<a a=a#>", +"output":[["StartTag", "a", {"a":"a#"}]]}, + +{"description":"<a a=a%>", +"input":"<a a=a%>", +"output":[["StartTag", "a", {"a":"a%"}]]}, + +{"description":"<a a=a&>", +"input":"<a a=a&>", +"output":[["StartTag", "a", {"a":"a&"}]]}, + +{"description":"<a a=a'>", +"input":"<a a=a'>", +"output":["ParseError", ["StartTag", "a", {"a":"a'"}]]}, + +{"description":"<a a=a(>", +"input":"<a a=a(>", +"output":[["StartTag", "a", {"a":"a("}]]}, + +{"description":"<a a=a->", +"input":"<a a=a->", +"output":[["StartTag", "a", {"a":"a-"}]]}, + +{"description":"<a a=a/>", +"input":"<a a=a/>", +"output":[["StartTag", "a", {"a":"a/"}]]}, + +{"description":"<a a=a0>", +"input":"<a a=a0>", +"output":[["StartTag", "a", {"a":"a0"}]]}, + +{"description":"<a a=a1>", +"input":"<a a=a1>", +"output":[["StartTag", "a", {"a":"a1"}]]}, + +{"description":"<a a=a9>", +"input":"<a a=a9>", +"output":[["StartTag", "a", {"a":"a9"}]]}, + +{"description":"<a a=a<>", +"input":"<a a=a<>", +"output":["ParseError", ["StartTag", "a", {"a":"a<"}]]}, + +{"description":"<a a=a=>", +"input":"<a a=a=>", +"output":["ParseError", ["StartTag", "a", {"a":"a="}]]}, + +{"description":"<a a=a>", +"input":"<a a=a>", +"output":[["StartTag", "a", {"a":"a"}]]}, + +{"description":"<a a=a?>", +"input":"<a a=a?>", +"output":[["StartTag", "a", {"a":"a?"}]]}, + +{"description":"<a a=a@>", +"input":"<a a=a@>", +"output":[["StartTag", "a", {"a":"a@"}]]}, + +{"description":"<a a=aA>", +"input":"<a a=aA>", +"output":[["StartTag", "a", {"a":"aA"}]]}, + +{"description":"<a a=aB>", +"input":"<a a=aB>", +"output":[["StartTag", "a", {"a":"aB"}]]}, + +{"description":"<a a=aY>", +"input":"<a a=aY>", +"output":[["StartTag", "a", {"a":"aY"}]]}, + +{"description":"<a a=aZ>", +"input":"<a a=aZ>", +"output":[["StartTag", "a", {"a":"aZ"}]]}, + +{"description":"<a a=a`>", +"input":"<a a=a`>", +"output":["ParseError", ["StartTag", "a", {"a":"a`"}]]}, + +{"description":"<a a=aa>", +"input":"<a a=aa>", +"output":[["StartTag", "a", {"a":"aa"}]]}, + +{"description":"<a a=ab>", +"input":"<a a=ab>", +"output":[["StartTag", "a", {"a":"ab"}]]}, + +{"description":"<a a=ay>", +"input":"<a a=ay>", +"output":[["StartTag", "a", {"a":"ay"}]]}, + +{"description":"<a a=az>", +"input":"<a a=az>", +"output":[["StartTag", "a", {"a":"az"}]]}, + +{"description":"<a a=a{>", +"input":"<a a=a{>", +"output":[["StartTag", "a", {"a":"a{"}]]}, + +{"description":"<a a=a\\uDBC0\\uDC00>", +"input":"<a a=a\uDBC0\uDC00>", +"output":[["StartTag", "a", {"a":"a\uDBC0\uDC00"}]]}, + +{"description":"<a a=b>", +"input":"<a a=b>", +"output":[["StartTag", "a", {"a":"b"}]]}, + +{"description":"<a a=y>", +"input":"<a a=y>", +"output":[["StartTag", "a", {"a":"y"}]]}, + +{"description":"<a a=z>", +"input":"<a a=z>", +"output":[["StartTag", "a", {"a":"z"}]]}, + +{"description":"<a a={>", +"input":"<a a={>", +"output":[["StartTag", "a", {"a":"{"}]]}, + +{"description":"<a a=\\uDBC0\\uDC00>", +"input":"<a a=\uDBC0\uDC00>", +"output":[["StartTag", "a", {"a":"\uDBC0\uDC00"}]]}, + +{"description":"<a a>", +"input":"<a a>", +"output":[["StartTag", "a", {"a":""}]]}, + +{"description":"<a a?>", +"input":"<a a?>", +"output":[["StartTag", "a", {"a?":""}]]}, + +{"description":"<a a@>", +"input":"<a a@>", +"output":[["StartTag", "a", {"a@":""}]]}, + +{"description":"<a aA>", +"input":"<a aA>", +"output":[["StartTag", "a", {"aa":""}]]}, + +{"description":"<a aB>", +"input":"<a aB>", +"output":[["StartTag", "a", {"ab":""}]]}, + +{"description":"<a aY>", +"input":"<a aY>", +"output":[["StartTag", "a", {"ay":""}]]}, + +{"description":"<a aZ>", +"input":"<a aZ>", +"output":[["StartTag", "a", {"az":""}]]}, + +{"description":"<a a[>", +"input":"<a a[>", +"output":[["StartTag", "a", {"a[":""}]]}, + +{"description":"<a a`>", +"input":"<a a`>", +"output":[["StartTag", "a", {"a`":""}]]}, + +{"description":"<a aa>", +"input":"<a aa>", +"output":[["StartTag", "a", {"aa":""}]]}, + +{"description":"<a ab>", +"input":"<a ab>", +"output":[["StartTag", "a", {"ab":""}]]}, + +{"description":"<a ay>", +"input":"<a ay>", +"output":[["StartTag", "a", {"ay":""}]]}, + +{"description":"<a az>", +"input":"<a az>", +"output":[["StartTag", "a", {"az":""}]]}, + +{"description":"<a a{>", +"input":"<a a{>", +"output":[["StartTag", "a", {"a{":""}]]}, + +{"description":"<a a\\uDBC0\\uDC00>", +"input":"<a a\uDBC0\uDC00>", +"output":[["StartTag", "a", {"a\uDBC0\uDC00":""}]]}, + +{"description":"<a b>", +"input":"<a b>", +"output":[["StartTag", "a", {"b":""}]]}, + +{"description":"<a y>", +"input":"<a y>", +"output":[["StartTag", "a", {"y":""}]]}, + +{"description":"<a z>", +"input":"<a z>", +"output":[["StartTag", "a", {"z":""}]]}, + +{"description":"<a {>", +"input":"<a {>", +"output":[["StartTag", "a", {"{":""}]]}, + +{"description":"<a \\uDBC0\\uDC00>", +"input":"<a \uDBC0\uDC00>", +"output":[["StartTag", "a", {"\uDBC0\uDC00":""}]]}, + +{"description":"<a!>", +"input":"<a!>", +"output":[["StartTag", "a!", {}]]}, + +{"description":"<a\">", +"input":"<a\">", +"output":[["StartTag", "a\"", {}]]}, + +{"description":"<a&>", +"input":"<a&>", +"output":[["StartTag", "a&", {}]]}, + +{"description":"<a'>", +"input":"<a'>", +"output":[["StartTag", "a'", {}]]}, + +{"description":"<a->", +"input":"<a->", +"output":[["StartTag", "a-", {}]]}, + +{"description":"<a.>", +"input":"<a.>", +"output":[["StartTag", "a.", {}]]}, + +{"description":"<a/>", +"input":"<a/>", +"output":[["StartTag", "a", {}, true]]}, + +{"description":"<a/\\u0000>", +"input":"<a/\u0000>", +"output":["ParseError", "ParseError", ["StartTag", "a", {"\uFFFD":""}]]}, + +{"description":"<a/\\u0009>", +"input":"<a/\u0009>", +"output":["ParseError", ["StartTag", "a", {}]]}, + +{"description":"<a/\\u000A>", +"input":"<a/\u000A>", +"output":["ParseError", ["StartTag", "a", {}]]}, + +{"description":"<a/\\u000B>", +"input":"<a/\u000B>", +"output":["ParseError", "ParseError", ["StartTag", "a", {"\u000B":""}]]}, + +{"description":"<a/\\u000C>", +"input":"<a/\u000C>", +"output":["ParseError", ["StartTag", "a", {}]]}, + +{"description":"<a/ >", +"input":"<a/ >", +"output":["ParseError", ["StartTag", "a", {}]]}, + +{"description":"<a/!>", +"input":"<a/!>", +"output":["ParseError", ["StartTag", "a", {"!":""}]]}, + +{"description":"<a/\">", +"input":"<a/\">", +"output":["ParseError", "ParseError", ["StartTag", "a", {"\"":""}]]}, + +{"description":"<a/&>", +"input":"<a/&>", +"output":["ParseError", ["StartTag", "a", {"&":""}]]}, + +{"description":"<a/'>", +"input":"<a/'>", +"output":["ParseError", "ParseError", ["StartTag", "a", {"'":""}]]}, + +{"description":"<a/->", +"input":"<a/->", +"output":["ParseError", ["StartTag", "a", {"-":""}]]}, + +{"description":"<a//>", +"input":"<a//>", +"output":["ParseError", ["StartTag", "a", {}, true]]}, + +{"description":"<a/0>", +"input":"<a/0>", +"output":["ParseError", ["StartTag", "a", {"0":""}]]}, + +{"description":"<a/1>", +"input":"<a/1>", +"output":["ParseError", ["StartTag", "a", {"1":""}]]}, + +{"description":"<a/9>", +"input":"<a/9>", +"output":["ParseError", ["StartTag", "a", {"9":""}]]}, + +{"description":"<a/<>", +"input":"<a/<>", +"output":["ParseError", "ParseError", ["StartTag", "a", {"<":""}]]}, + +{"description":"<a/=>", +"input":"<a/=>", +"output":["ParseError", "ParseError", ["StartTag", "a", {"=":""}]]}, + +{"description":"<a/>", +"input":"<a/>", +"output":[["StartTag", "a", {}, true]]}, + +{"description":"<a/?>", +"input":"<a/?>", +"output":["ParseError", ["StartTag", "a", {"?":""}]]}, + +{"description":"<a/@>", +"input":"<a/@>", +"output":["ParseError", ["StartTag", "a", {"@":""}]]}, + +{"description":"<a/A>", +"input":"<a/A>", +"output":["ParseError", ["StartTag", "a", {"a":""}]]}, + +{"description":"<a/B>", +"input":"<a/B>", +"output":["ParseError", ["StartTag", "a", {"b":""}]]}, + +{"description":"<a/Y>", +"input":"<a/Y>", +"output":["ParseError", ["StartTag", "a", {"y":""}]]}, + +{"description":"<a/Z>", +"input":"<a/Z>", +"output":["ParseError", ["StartTag", "a", {"z":""}]]}, + +{"description":"<a/`>", +"input":"<a/`>", +"output":["ParseError", ["StartTag", "a", {"`":""}]]}, + +{"description":"<a/a>", +"input":"<a/a>", +"output":["ParseError", ["StartTag", "a", {"a":""}]]}, + +{"description":"<a/b>", +"input":"<a/b>", +"output":["ParseError", ["StartTag", "a", {"b":""}]]}, + +{"description":"<a/y>", +"input":"<a/y>", +"output":["ParseError", ["StartTag", "a", {"y":""}]]}, + +{"description":"<a/z>", +"input":"<a/z>", +"output":["ParseError", ["StartTag", "a", {"z":""}]]}, + +{"description":"<a/{>", +"input":"<a/{>", +"output":["ParseError", ["StartTag", "a", {"{":""}]]}, + +{"description":"<a/\\uDBC0\\uDC00>", +"input":"<a/\uDBC0\uDC00>", +"output":["ParseError", ["StartTag", "a", {"\uDBC0\uDC00":""}]]}, + +{"description":"<a0>", +"input":"<a0>", +"output":[["StartTag", "a0", {}]]}, + +{"description":"<a1>", +"input":"<a1>", +"output":[["StartTag", "a1", {}]]}, + +{"description":"<a9>", +"input":"<a9>", +"output":[["StartTag", "a9", {}]]}, + +{"description":"<a<>", +"input":"<a<>", +"output":[["StartTag", "a<", {}]]}, + +{"description":"<a=>", +"input":"<a=>", +"output":[["StartTag", "a=", {}]]}, + +{"description":"<a>", +"input":"<a>", +"output":[["StartTag", "a", {}]]}, + +{"description":"<a?>", +"input":"<a?>", +"output":[["StartTag", "a?", {}]]}, + +{"description":"<a@>", +"input":"<a@>", +"output":[["StartTag", "a@", {}]]}, + +{"description":"<aA>", +"input":"<aA>", +"output":[["StartTag", "aa", {}]]}, + +{"description":"<aB>", +"input":"<aB>", +"output":[["StartTag", "ab", {}]]}, + +{"description":"<aY>", +"input":"<aY>", +"output":[["StartTag", "ay", {}]]}, + +{"description":"<aZ>", +"input":"<aZ>", +"output":[["StartTag", "az", {}]]}, + +{"description":"<a[>", +"input":"<a[>", +"output":[["StartTag", "a[", {}]]}, + +{"description":"<a`>", +"input":"<a`>", +"output":[["StartTag", "a`", {}]]}, + +{"description":"<aa>", +"input":"<aa>", +"output":[["StartTag", "aa", {}]]}, + +{"description":"<ab>", +"input":"<ab>", +"output":[["StartTag", "ab", {}]]}, + +{"description":"<ay>", +"input":"<ay>", +"output":[["StartTag", "ay", {}]]}, + +{"description":"<az>", +"input":"<az>", +"output":[["StartTag", "az", {}]]}, + +{"description":"<a{>", +"input":"<a{>", +"output":[["StartTag", "a{", {}]]}, + +{"description":"<a\\uDBC0\\uDC00>", +"input":"<a\uDBC0\uDC00>", +"output":[["StartTag", "a\uDBC0\uDC00", {}]]}, + +{"description":"<b>", +"input":"<b>", +"output":[["StartTag", "b", {}]]}, + +{"description":"<y>", +"input":"<y>", +"output":[["StartTag", "y", {}]]}, + +{"description":"<z>", +"input":"<z>", +"output":[["StartTag", "z", {}]]}, + +{"description":"<{", +"input":"<{", +"output":["ParseError", ["Character", "<{"]]}, + +{"description":"<\\uDBC0\\uDC00", +"input":"<\uDBC0\uDC00", +"output":["ParseError", ["Character", "<\uDBC0\uDC00"]]}, + +{"description":"=", +"input":"=", +"output":[["Character", "="]]}, + +{"description":">", +"input":">", +"output":[["Character", ">"]]}, + +{"description":"?", +"input":"?", +"output":[["Character", "?"]]}, + +{"description":"@", +"input":"@", +"output":[["Character", "@"]]}, + +{"description":"A", +"input":"A", +"output":[["Character", "A"]]}, + +{"description":"B", +"input":"B", +"output":[["Character", "B"]]}, + +{"description":"Y", +"input":"Y", +"output":[["Character", "Y"]]}, + +{"description":"Z", +"input":"Z", +"output":[["Character", "Z"]]}, + +{"description":"`", +"input":"`", +"output":[["Character", "`"]]}, + +{"description":"a", +"input":"a", +"output":[["Character", "a"]]}, + +{"description":"b", +"input":"b", +"output":[["Character", "b"]]}, + +{"description":"y", +"input":"y", +"output":[["Character", "y"]]}, + +{"description":"z", +"input":"z", +"output":[["Character", "z"]]}, + +{"description":"{", +"input":"{", +"output":[["Character", "{"]]}, + +{"description":"\\uDBC0\\uDC00", +"input":"\uDBC0\uDC00", +"output":[["Character", "\uDBC0\uDC00"]]} + +]} diff --git a/tests/data/tokenizer/test4.test b/tests/data/tokenizer/test4.test new file mode 100644 index 0000000..80f859e --- /dev/null +++ b/tests/data/tokenizer/test4.test @@ -0,0 +1,344 @@ +{"tests": [ + +{"description":"< in attribute name", +"input":"<z/0 <>", +"output":["ParseError", "ParseError", ["StartTag", "z", {"0": "", "<": ""}]]}, + +{"description":"< in attribute value", +"input":"<z x=<>", +"output":["ParseError", ["StartTag", "z", {"x": "<"}]]}, + +{"description":"= in unquoted attribute value", +"input":"<z z=z=z>", +"output":["ParseError", ["StartTag", "z", {"z": "z=z"}]]}, + +{"description":"= attribute", +"input":"<z =>", +"output":["ParseError", ["StartTag", "z", {"=": ""}]]}, + +{"description":"== attribute", +"input":"<z ==>", +"output":["ParseError", "ParseError", ["StartTag", "z", {"=": ""}]]}, + +{"description":"=== attribute", +"input":"<z ===>", +"output":["ParseError", "ParseError", ["StartTag", "z", {"=": "="}]]}, + +{"description":"==== attribute", +"input":"<z ====>", +"output":["ParseError", "ParseError", "ParseError", ["StartTag", "z", {"=": "=="}]]}, + +{"description":"Allowed \" after ampersand in attribute value", +"input":"<z z=\"&\">", +"output":[["StartTag", "z", {"z": "&"}]]}, + +{"description":"Non-allowed ' after ampersand in attribute value", +"input":"<z z=\"&'\">", +"output":["ParseError", ["StartTag", "z", {"z": "&'"}]]}, + +{"description":"Allowed ' after ampersand in attribute value", +"input":"<z z='&'>", +"output":[["StartTag", "z", {"z": "&"}]]}, + +{"description":"Non-allowed \" after ampersand in attribute value", +"input":"<z z='&\"'>", +"output":["ParseError", ["StartTag", "z", {"z": "&\""}]]}, + +{"description":"Text after bogus character reference", +"input":"<z z='&xlink_xmlns;'>bar<z>", +"output":["ParseError",["StartTag","z",{"z":"&xlink_xmlns;"}],["Character","bar"],["StartTag","z",{}]]}, + +{"description":"Text after hex character reference", +"input":"<z z='&#x0020; foo'>bar<z>", +"output":[["StartTag","z",{"z":" foo"}],["Character","bar"],["StartTag","z",{}]]}, + +{"description":"Attribute name starting with \"", +"input":"<foo \"='bar'>", +"output":["ParseError", ["StartTag", "foo", {"\"": "bar"}]]}, + +{"description":"Attribute name starting with '", +"input":"<foo '='bar'>", +"output":["ParseError", ["StartTag", "foo", {"'": "bar"}]]}, + +{"description":"Attribute name containing \"", +"input":"<foo a\"b='bar'>", +"output":["ParseError", ["StartTag", "foo", {"a\"b": "bar"}]]}, + +{"description":"Attribute name containing '", +"input":"<foo a'b='bar'>", +"output":["ParseError", ["StartTag", "foo", {"a'b": "bar"}]]}, + +{"description":"Unquoted attribute value containing '", +"input":"<foo a=b'c>", +"output":["ParseError", ["StartTag", "foo", {"a": "b'c"}]]}, + +{"description":"Unquoted attribute value containing \"", +"input":"<foo a=b\"c>", +"output":["ParseError", ["StartTag", "foo", {"a": "b\"c"}]]}, + +{"description":"Double-quoted attribute value not followed by whitespace", +"input":"<foo a=\"b\"c>", +"output":["ParseError", ["StartTag", "foo", {"a": "b", "c": ""}]]}, + +{"description":"Single-quoted attribute value not followed by whitespace", +"input":"<foo a='b'c>", +"output":["ParseError", ["StartTag", "foo", {"a": "b", "c": ""}]]}, + +{"description":"Quoted attribute followed by permitted /", +"input":"<br a='b'/>", +"output":[["StartTag","br",{"a":"b"},true]]}, + +{"description":"Quoted attribute followed by non-permitted /", +"input":"<bar a='b'/>", +"output":[["StartTag","bar",{"a":"b"},true]]}, + +{"description":"CR EOF after doctype name", +"input":"<!doctype html \r", +"output":["ParseError", ["DOCTYPE", "html", null, null, false]]}, + +{"description":"CR EOF in tag name", +"input":"<z\r", +"output":["ParseError"]}, + +{"description":"Slash EOF in tag name", +"input":"<z/", +"output":["ParseError"]}, + +{"description":"Zero hex numeric entity", +"input":"&#x0", +"output":["ParseError", "ParseError", ["Character", "\uFFFD"]]}, + +{"description":"Zero decimal numeric entity", +"input":"&#0", +"output":["ParseError", "ParseError", ["Character", "\uFFFD"]]}, + +{"description":"Zero-prefixed hex numeric entity", +"input":"&#x000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000041;", +"output":[["Character", "A"]]}, + +{"description":"Zero-prefixed decimal numeric entity", +"input":"&#000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000065;", +"output":[["Character", "A"]]}, + +{"description":"Empty hex numeric entities", +"input":"&#x &#X ", +"output":["ParseError", ["Character", "&#x "], "ParseError", ["Character", "&#X "]]}, + +{"description":"Empty decimal numeric entities", +"input":"&# &#; ", +"output":["ParseError", ["Character", "&# "], "ParseError", ["Character", "&#; "]]}, + +{"description":"Non-BMP numeric entity", +"input":"&#x10000;", +"output":[["Character", "\uD800\uDC00"]]}, + +{"description":"Maximum non-BMP numeric entity", +"input":"&#X10FFFF;", +"output":["ParseError", ["Character", "\uDBFF\uDFFF"]]}, + +{"description":"Above maximum numeric entity", +"input":"&#x110000;", +"output":["ParseError", ["Character", "\uFFFD"]]}, + +{"description":"32-bit hex numeric entity", +"input":"&#x80000041;", +"output":["ParseError", ["Character", "\uFFFD"]]}, + +{"description":"33-bit hex numeric entity", +"input":"&#x100000041;", +"output":["ParseError", ["Character", "\uFFFD"]]}, + +{"description":"33-bit decimal numeric entity", +"input":"&#4294967361;", +"output":["ParseError", ["Character", "\uFFFD"]]}, + +{"description":"65-bit hex numeric entity", +"input":"&#x10000000000000041;", +"output":["ParseError", ["Character", "\uFFFD"]]}, + +{"description":"65-bit decimal numeric entity", +"input":"&#18446744073709551681;", +"output":["ParseError", ["Character", "\uFFFD"]]}, + +{"description":"Surrogate code point edge cases", +"input":"&#xD7FF;&#xD800;&#xD801;&#xDFFE;&#xDFFF;&#xE000;", +"output":[["Character", "\uD7FF"], "ParseError", ["Character", "\uFFFD"], "ParseError", ["Character", "\uFFFD"], "ParseError", ["Character", "\uFFFD"], "ParseError", ["Character", "\uFFFD\uE000"]]}, + +{"description":"Uppercase start tag name", +"input":"<X>", +"output":[["StartTag", "x", {}]]}, + +{"description":"Uppercase end tag name", +"input":"</X>", +"output":[["EndTag", "x"]]}, + +{"description":"Uppercase attribute name", +"input":"<x X>", +"output":[["StartTag", "x", { "x":"" }]]}, + +{"description":"Tag/attribute name case edge values", +"input":"<x@AZ[`az{ @AZ[`az{>", +"output":[["StartTag", "x@az[`az{", { "@az[`az{":"" }]]}, + +{"description":"Duplicate different-case attributes", +"input":"<x x=1 x=2 X=3>", +"output":["ParseError", "ParseError", ["StartTag", "x", { "x":"1" }]]}, + +{"description":"Uppercase close tag attributes", +"input":"</x X>", +"output":["ParseError", ["EndTag", "x"]]}, + +{"description":"Duplicate close tag attributes", +"input":"</x x x>", +"output":["ParseError", "ParseError", ["EndTag", "x"]]}, + +{"description":"Permitted slash", +"input":"<br/>", +"output":[["StartTag","br",{},true]]}, + +{"description":"Non-permitted slash", +"input":"<xr/>", +"output":[["StartTag","xr",{},true]]}, + +{"description":"Permitted slash but in close tag", +"input":"</br/>", +"output":["ParseError", ["EndTag", "br"]]}, + +{"description":"Doctype public case-sensitivity (1)", +"input":"<!DoCtYpE HtMl PuBlIc \"AbC\" \"XyZ\">", +"output":[["DOCTYPE", "html", "AbC", "XyZ", true]]}, + +{"description":"Doctype public case-sensitivity (2)", +"input":"<!dOcTyPe hTmL pUbLiC \"aBc\" \"xYz\">", +"output":[["DOCTYPE", "html", "aBc", "xYz", true]]}, + +{"description":"Doctype system case-sensitivity (1)", +"input":"<!DoCtYpE HtMl SyStEm \"XyZ\">", +"output":[["DOCTYPE", "html", null, "XyZ", true]]}, + +{"description":"Doctype system case-sensitivity (2)", +"input":"<!dOcTyPe hTmL sYsTeM \"xYz\">", +"output":[["DOCTYPE", "html", null, "xYz", true]]}, + +{"description":"U+0000 in lookahead region after non-matching character", +"input":"<!doc>\u0000", +"output":["ParseError", ["Comment", "doc"], "ParseError", ["Character", "\u0000"]], +"ignoreErrorOrder":true}, + +{"description":"U+0000 in lookahead region", +"input":"<!doc\u0000", +"output":["ParseError", ["Comment", "doc\uFFFD"]], +"ignoreErrorOrder":true}, + +{"description":"U+0080 in lookahead region", +"input":"<!doc\u0080", +"output":["ParseError", "ParseError", ["Comment", "doc\u0080"]], +"ignoreErrorOrder":true}, + +{"description":"U+FDD1 in lookahead region", +"input":"<!doc\uFDD1", +"output":["ParseError", "ParseError", ["Comment", "doc\uFDD1"]], +"ignoreErrorOrder":true}, + +{"description":"U+1FFFF in lookahead region", +"input":"<!doc\uD83F\uDFFF", +"output":["ParseError", "ParseError", ["Comment", "doc\uD83F\uDFFF"]], +"ignoreErrorOrder":true}, + +{"description":"CR followed by non-LF", +"input":"\r?", +"output":[["Character", "\n?"]]}, + +{"description":"CR at EOF", +"input":"\r", +"output":[["Character", "\n"]]}, + +{"description":"LF at EOF", +"input":"\n", +"output":[["Character", "\n"]]}, + +{"description":"CR LF", +"input":"\r\n", +"output":[["Character", "\n"]]}, + +{"description":"CR CR", +"input":"\r\r", +"output":[["Character", "\n\n"]]}, + +{"description":"LF LF", +"input":"\n\n", +"output":[["Character", "\n\n"]]}, + +{"description":"LF CR", +"input":"\n\r", +"output":[["Character", "\n\n"]]}, + +{"description":"text CR CR CR text", +"input":"text\r\r\rtext", +"output":[["Character", "text\n\n\ntext"]]}, + +{"description":"Doctype publik", +"input":"<!DOCTYPE html PUBLIK \"AbC\" \"XyZ\">", +"output":["ParseError", ["DOCTYPE", "html", null, null, false]]}, + +{"description":"Doctype publi", +"input":"<!DOCTYPE html PUBLI", +"output":["ParseError", ["DOCTYPE", "html", null, null, false]]}, + +{"description":"Doctype sistem", +"input":"<!DOCTYPE html SISTEM \"AbC\">", +"output":["ParseError", ["DOCTYPE", "html", null, null, false]]}, + +{"description":"Doctype sys", +"input":"<!DOCTYPE html SYS", +"output":["ParseError", ["DOCTYPE", "html", null, null, false]]}, + +{"description":"Doctype html x>text", +"input":"<!DOCTYPE html x>text", +"output":["ParseError", ["DOCTYPE", "html", null, null, false], ["Character", "text"]]}, + +{"description":"Grave accent in unquoted attribute", +"input":"<a a=aa`>", +"output":["ParseError", ["StartTag", "a", {"a":"aa`"}]]}, + +{"description":"EOF in tag name state ", +"input":"<a", +"output":["ParseError"]}, + +{"description":"EOF in tag name state", +"input":"<a", +"output":["ParseError"]}, + +{"description":"EOF in before attribute name state", +"input":"<a ", +"output":["ParseError"]}, + +{"description":"EOF in attribute name state", +"input":"<a a", +"output":["ParseError"]}, + +{"description":"EOF in after attribute name state", +"input":"<a a ", +"output":["ParseError"]}, + +{"description":"EOF in before attribute value state", +"input":"<a a =", +"output":["ParseError"]}, + +{"description":"EOF in attribute value (double quoted) state", +"input":"<a a =\"a", +"output":["ParseError"]}, + +{"description":"EOF in attribute value (single quoted) state", +"input":"<a a ='a", +"output":["ParseError"]}, + +{"description":"EOF in attribute value (unquoted) state", +"input":"<a a =a", +"output":["ParseError"]}, + +{"description":"EOF in after attribute value state", +"input":"<a a ='a'", +"output":["ParseError"]} + +]} diff --git a/tests/data/tokenizer/unicodeChars.test b/tests/data/tokenizer/unicodeChars.test new file mode 100644 index 0000000..c778668 --- /dev/null +++ b/tests/data/tokenizer/unicodeChars.test @@ -0,0 +1,1295 @@ +{"tests": [ + +{"description": "Invalid Unicode character U+0001", +"input": "\u0001", +"output": ["ParseError", ["Character", "\u0001"]]}, + +{"description": "Invalid Unicode character U+0002", +"input": "\u0002", +"output": ["ParseError", ["Character", "\u0002"]]}, + +{"description": "Invalid Unicode character U+0003", +"input": "\u0003", +"output": ["ParseError", ["Character", "\u0003"]]}, + +{"description": "Invalid Unicode character U+0004", +"input": "\u0004", +"output": ["ParseError", ["Character", "\u0004"]]}, + +{"description": "Invalid Unicode character U+0005", +"input": "\u0005", +"output": ["ParseError", ["Character", "\u0005"]]}, + +{"description": "Invalid Unicode character U+0006", +"input": "\u0006", +"output": ["ParseError", ["Character", "\u0006"]]}, + +{"description": "Invalid Unicode character U+0007", +"input": "\u0007", +"output": ["ParseError", ["Character", "\u0007"]]}, + +{"description": "Invalid Unicode character U+0008", +"input": "\u0008", +"output": ["ParseError", ["Character", "\u0008"]]}, + +{"description": "Invalid Unicode character U+000B", +"input": "\u000B", +"output": ["ParseError", ["Character", "\u000B"]]}, + +{"description": "Invalid Unicode character U+000E", +"input": "\u000E", +"output": ["ParseError", ["Character", "\u000E"]]}, + +{"description": "Invalid Unicode character U+000F", +"input": "\u000F", +"output": ["ParseError", ["Character", "\u000F"]]}, + +{"description": "Invalid Unicode character U+0010", +"input": "\u0010", +"output": ["ParseError", ["Character", "\u0010"]]}, + +{"description": "Invalid Unicode character U+0011", +"input": "\u0011", +"output": ["ParseError", ["Character", "\u0011"]]}, + +{"description": "Invalid Unicode character U+0012", +"input": "\u0012", +"output": ["ParseError", ["Character", "\u0012"]]}, + +{"description": "Invalid Unicode character U+0013", +"input": "\u0013", +"output": ["ParseError", ["Character", "\u0013"]]}, + +{"description": "Invalid Unicode character U+0014", +"input": "\u0014", +"output": ["ParseError", ["Character", "\u0014"]]}, + +{"description": "Invalid Unicode character U+0015", +"input": "\u0015", +"output": ["ParseError", ["Character", "\u0015"]]}, + +{"description": "Invalid Unicode character U+0016", +"input": "\u0016", +"output": ["ParseError", ["Character", "\u0016"]]}, + +{"description": "Invalid Unicode character U+0017", +"input": "\u0017", +"output": ["ParseError", ["Character", "\u0017"]]}, + +{"description": "Invalid Unicode character U+0018", +"input": "\u0018", +"output": ["ParseError", ["Character", "\u0018"]]}, + +{"description": "Invalid Unicode character U+0019", +"input": "\u0019", +"output": ["ParseError", ["Character", "\u0019"]]}, + +{"description": "Invalid Unicode character U+001A", +"input": "\u001A", +"output": ["ParseError", ["Character", "\u001A"]]}, + +{"description": "Invalid Unicode character U+001B", +"input": "\u001B", +"output": ["ParseError", ["Character", "\u001B"]]}, + +{"description": "Invalid Unicode character U+001C", +"input": "\u001C", +"output": ["ParseError", ["Character", "\u001C"]]}, + +{"description": "Invalid Unicode character U+001D", +"input": "\u001D", +"output": ["ParseError", ["Character", "\u001D"]]}, + +{"description": "Invalid Unicode character U+001E", +"input": "\u001E", +"output": ["ParseError", ["Character", "\u001E"]]}, + +{"description": "Invalid Unicode character U+001F", +"input": "\u001F", +"output": ["ParseError", ["Character", "\u001F"]]}, + +{"description": "Invalid Unicode character U+007F", +"input": "\u007F", +"output": ["ParseError", ["Character", "\u007F"]]}, + +{"description": "Invalid Unicode character U+FDD0", +"input": "\uFDD0", +"output": ["ParseError", ["Character", "\uFDD0"]]}, + +{"description": "Invalid Unicode character U+FDD1", +"input": "\uFDD1", +"output": ["ParseError", ["Character", "\uFDD1"]]}, + +{"description": "Invalid Unicode character U+FDD2", +"input": "\uFDD2", +"output": ["ParseError", ["Character", "\uFDD2"]]}, + +{"description": "Invalid Unicode character U+FDD3", +"input": "\uFDD3", +"output": ["ParseError", ["Character", "\uFDD3"]]}, + +{"description": "Invalid Unicode character U+FDD4", +"input": "\uFDD4", +"output": ["ParseError", ["Character", "\uFDD4"]]}, + +{"description": "Invalid Unicode character U+FDD5", +"input": "\uFDD5", +"output": ["ParseError", ["Character", "\uFDD5"]]}, + +{"description": "Invalid Unicode character U+FDD6", +"input": "\uFDD6", +"output": ["ParseError", ["Character", "\uFDD6"]]}, + +{"description": "Invalid Unicode character U+FDD7", +"input": "\uFDD7", +"output": ["ParseError", ["Character", "\uFDD7"]]}, + +{"description": "Invalid Unicode character U+FDD8", +"input": "\uFDD8", +"output": ["ParseError", ["Character", "\uFDD8"]]}, + +{"description": "Invalid Unicode character U+FDD9", +"input": "\uFDD9", +"output": ["ParseError", ["Character", "\uFDD9"]]}, + +{"description": "Invalid Unicode character U+FDDA", +"input": "\uFDDA", +"output": ["ParseError", ["Character", "\uFDDA"]]}, + +{"description": "Invalid Unicode character U+FDDB", +"input": "\uFDDB", +"output": ["ParseError", ["Character", "\uFDDB"]]}, + +{"description": "Invalid Unicode character U+FDDC", +"input": "\uFDDC", +"output": ["ParseError", ["Character", "\uFDDC"]]}, + +{"description": "Invalid Unicode character U+FDDD", +"input": "\uFDDD", +"output": ["ParseError", ["Character", "\uFDDD"]]}, + +{"description": "Invalid Unicode character U+FDDE", +"input": "\uFDDE", +"output": ["ParseError", ["Character", "\uFDDE"]]}, + +{"description": "Invalid Unicode character U+FDDF", +"input": "\uFDDF", +"output": ["ParseError", ["Character", "\uFDDF"]]}, + +{"description": "Invalid Unicode character U+FDE0", +"input": "\uFDE0", +"output": ["ParseError", ["Character", "\uFDE0"]]}, + +{"description": "Invalid Unicode character U+FDE1", +"input": "\uFDE1", +"output": ["ParseError", ["Character", "\uFDE1"]]}, + +{"description": "Invalid Unicode character U+FDE2", +"input": "\uFDE2", +"output": ["ParseError", ["Character", "\uFDE2"]]}, + +{"description": "Invalid Unicode character U+FDE3", +"input": "\uFDE3", +"output": ["ParseError", ["Character", "\uFDE3"]]}, + +{"description": "Invalid Unicode character U+FDE4", +"input": "\uFDE4", +"output": ["ParseError", ["Character", "\uFDE4"]]}, + +{"description": "Invalid Unicode character U+FDE5", +"input": "\uFDE5", +"output": ["ParseError", ["Character", "\uFDE5"]]}, + +{"description": "Invalid Unicode character U+FDE6", +"input": "\uFDE6", +"output": ["ParseError", ["Character", "\uFDE6"]]}, + +{"description": "Invalid Unicode character U+FDE7", +"input": "\uFDE7", +"output": ["ParseError", ["Character", "\uFDE7"]]}, + +{"description": "Invalid Unicode character U+FDE8", +"input": "\uFDE8", +"output": ["ParseError", ["Character", "\uFDE8"]]}, + +{"description": "Invalid Unicode character U+FDE9", +"input": "\uFDE9", +"output": ["ParseError", ["Character", "\uFDE9"]]}, + +{"description": "Invalid Unicode character U+FDEA", +"input": "\uFDEA", +"output": ["ParseError", ["Character", "\uFDEA"]]}, + +{"description": "Invalid Unicode character U+FDEB", +"input": "\uFDEB", +"output": ["ParseError", ["Character", "\uFDEB"]]}, + +{"description": "Invalid Unicode character U+FDEC", +"input": "\uFDEC", +"output": ["ParseError", ["Character", "\uFDEC"]]}, + +{"description": "Invalid Unicode character U+FDED", +"input": "\uFDED", +"output": ["ParseError", ["Character", "\uFDED"]]}, + +{"description": "Invalid Unicode character U+FDEE", +"input": "\uFDEE", +"output": ["ParseError", ["Character", "\uFDEE"]]}, + +{"description": "Invalid Unicode character U+FDEF", +"input": "\uFDEF", +"output": ["ParseError", ["Character", "\uFDEF"]]}, + +{"description": "Invalid Unicode character U+FFFE", +"input": "\uFFFE", +"output": ["ParseError", ["Character", "\uFFFE"]]}, + +{"description": "Invalid Unicode character U+FFFF", +"input": "\uFFFF", +"output": ["ParseError", ["Character", "\uFFFF"]]}, + +{"description": "Invalid Unicode character U+1FFFE", +"input": "\uD83F\uDFFE", +"output": ["ParseError", ["Character", "\uD83F\uDFFE"]]}, + +{"description": "Invalid Unicode character U+1FFFF", +"input": "\uD83F\uDFFF", +"output": ["ParseError", ["Character", "\uD83F\uDFFF"]]}, + +{"description": "Invalid Unicode character U+2FFFE", +"input": "\uD87F\uDFFE", +"output": ["ParseError", ["Character", "\uD87F\uDFFE"]]}, + +{"description": "Invalid Unicode character U+2FFFF", +"input": "\uD87F\uDFFF", +"output": ["ParseError", ["Character", "\uD87F\uDFFF"]]}, + +{"description": "Invalid Unicode character U+3FFFE", +"input": "\uD8BF\uDFFE", +"output": ["ParseError", ["Character", "\uD8BF\uDFFE"]]}, + +{"description": "Invalid Unicode character U+3FFFF", +"input": "\uD8BF\uDFFF", +"output": ["ParseError", ["Character", "\uD8BF\uDFFF"]]}, + +{"description": "Invalid Unicode character U+4FFFE", +"input": "\uD8FF\uDFFE", +"output": ["ParseError", ["Character", "\uD8FF\uDFFE"]]}, + +{"description": "Invalid Unicode character U+4FFFF", +"input": "\uD8FF\uDFFF", +"output": ["ParseError", ["Character", "\uD8FF\uDFFF"]]}, + +{"description": "Invalid Unicode character U+5FFFE", +"input": "\uD93F\uDFFE", +"output": ["ParseError", ["Character", "\uD93F\uDFFE"]]}, + +{"description": "Invalid Unicode character U+5FFFF", +"input": "\uD93F\uDFFF", +"output": ["ParseError", ["Character", "\uD93F\uDFFF"]]}, + +{"description": "Invalid Unicode character U+6FFFE", +"input": "\uD97F\uDFFE", +"output": ["ParseError", ["Character", "\uD97F\uDFFE"]]}, + +{"description": "Invalid Unicode character U+6FFFF", +"input": "\uD97F\uDFFF", +"output": ["ParseError", ["Character", "\uD97F\uDFFF"]]}, + +{"description": "Invalid Unicode character U+7FFFE", +"input": "\uD9BF\uDFFE", +"output": ["ParseError", ["Character", "\uD9BF\uDFFE"]]}, + +{"description": "Invalid Unicode character U+7FFFF", +"input": "\uD9BF\uDFFF", +"output": ["ParseError", ["Character", "\uD9BF\uDFFF"]]}, + +{"description": "Invalid Unicode character U+8FFFE", +"input": "\uD9FF\uDFFE", +"output": ["ParseError", ["Character", "\uD9FF\uDFFE"]]}, + +{"description": "Invalid Unicode character U+8FFFF", +"input": "\uD9FF\uDFFF", +"output": ["ParseError", ["Character", "\uD9FF\uDFFF"]]}, + +{"description": "Invalid Unicode character U+9FFFE", +"input": "\uDA3F\uDFFE", +"output": ["ParseError", ["Character", "\uDA3F\uDFFE"]]}, + +{"description": "Invalid Unicode character U+9FFFF", +"input": "\uDA3F\uDFFF", +"output": ["ParseError", ["Character", "\uDA3F\uDFFF"]]}, + +{"description": "Invalid Unicode character U+AFFFE", +"input": "\uDA7F\uDFFE", +"output": ["ParseError", ["Character", "\uDA7F\uDFFE"]]}, + +{"description": "Invalid Unicode character U+AFFFF", +"input": "\uDA7F\uDFFF", +"output": ["ParseError", ["Character", "\uDA7F\uDFFF"]]}, + +{"description": "Invalid Unicode character U+BFFFE", +"input": "\uDABF\uDFFE", +"output": ["ParseError", ["Character", "\uDABF\uDFFE"]]}, + +{"description": "Invalid Unicode character U+BFFFF", +"input": "\uDABF\uDFFF", +"output": ["ParseError", ["Character", "\uDABF\uDFFF"]]}, + +{"description": "Invalid Unicode character U+CFFFE", +"input": "\uDAFF\uDFFE", +"output": ["ParseError", ["Character", "\uDAFF\uDFFE"]]}, + +{"description": "Invalid Unicode character U+CFFFF", +"input": "\uDAFF\uDFFF", +"output": ["ParseError", ["Character", "\uDAFF\uDFFF"]]}, + +{"description": "Invalid Unicode character U+DFFFE", +"input": "\uDB3F\uDFFE", +"output": ["ParseError", ["Character", "\uDB3F\uDFFE"]]}, + +{"description": "Invalid Unicode character U+DFFFF", +"input": "\uDB3F\uDFFF", +"output": ["ParseError", ["Character", "\uDB3F\uDFFF"]]}, + +{"description": "Invalid Unicode character U+EFFFE", +"input": "\uDB7F\uDFFE", +"output": ["ParseError", ["Character", "\uDB7F\uDFFE"]]}, + +{"description": "Invalid Unicode character U+EFFFF", +"input": "\uDB7F\uDFFF", +"output": ["ParseError", ["Character", "\uDB7F\uDFFF"]]}, + +{"description": "Invalid Unicode character U+FFFFE", +"input": "\uDBBF\uDFFE", +"output": ["ParseError", ["Character", "\uDBBF\uDFFE"]]}, + +{"description": "Invalid Unicode character U+FFFFF", +"input": "\uDBBF\uDFFF", +"output": ["ParseError", ["Character", "\uDBBF\uDFFF"]]}, + +{"description": "Invalid Unicode character U+10FFFE", +"input": "\uDBFF\uDFFE", +"output": ["ParseError", ["Character", "\uDBFF\uDFFE"]]}, + +{"description": "Invalid Unicode character U+10FFFF", +"input": "\uDBFF\uDFFF", +"output": ["ParseError", ["Character", "\uDBFF\uDFFF"]]}, + +{"description": "Valid Unicode character U+0009", +"input": "\u0009", +"output": [["Character", "\u0009"]]}, + +{"description": "Valid Unicode character U+000A", +"input": "\u000A", +"output": [["Character", "\u000A"]]}, + +{"description": "Valid Unicode character U+0020", +"input": "\u0020", +"output": [["Character", "\u0020"]]}, + +{"description": "Valid Unicode character U+0021", +"input": "\u0021", +"output": [["Character", "\u0021"]]}, + +{"description": "Valid Unicode character U+0022", +"input": "\u0022", +"output": [["Character", "\u0022"]]}, + +{"description": "Valid Unicode character U+0023", +"input": "\u0023", +"output": [["Character", "\u0023"]]}, + +{"description": "Valid Unicode character U+0024", +"input": "\u0024", +"output": [["Character", "\u0024"]]}, + +{"description": "Valid Unicode character U+0025", +"input": "\u0025", +"output": [["Character", "\u0025"]]}, + +{"description": "Valid Unicode character U+0026", +"input": "\u0026", +"output": [["Character", "\u0026"]]}, + +{"description": "Valid Unicode character U+0027", +"input": "\u0027", +"output": [["Character", "\u0027"]]}, + +{"description": "Valid Unicode character U+0028", +"input": "\u0028", +"output": [["Character", "\u0028"]]}, + +{"description": "Valid Unicode character U+0029", +"input": "\u0029", +"output": [["Character", "\u0029"]]}, + +{"description": "Valid Unicode character U+002A", +"input": "\u002A", +"output": [["Character", "\u002A"]]}, + +{"description": "Valid Unicode character U+002B", +"input": "\u002B", +"output": [["Character", "\u002B"]]}, + +{"description": "Valid Unicode character U+002C", +"input": "\u002C", +"output": [["Character", "\u002C"]]}, + +{"description": "Valid Unicode character U+002D", +"input": "\u002D", +"output": [["Character", "\u002D"]]}, + +{"description": "Valid Unicode character U+002E", +"input": "\u002E", +"output": [["Character", "\u002E"]]}, + +{"description": "Valid Unicode character U+002F", +"input": "\u002F", +"output": [["Character", "\u002F"]]}, + +{"description": "Valid Unicode character U+0030", +"input": "\u0030", +"output": [["Character", "\u0030"]]}, + +{"description": "Valid Unicode character U+0031", +"input": "\u0031", +"output": [["Character", "\u0031"]]}, + +{"description": "Valid Unicode character U+0032", +"input": "\u0032", +"output": [["Character", "\u0032"]]}, + +{"description": "Valid Unicode character U+0033", +"input": "\u0033", +"output": [["Character", "\u0033"]]}, + +{"description": "Valid Unicode character U+0034", +"input": "\u0034", +"output": [["Character", "\u0034"]]}, + +{"description": "Valid Unicode character U+0035", +"input": "\u0035", +"output": [["Character", "\u0035"]]}, + +{"description": "Valid Unicode character U+0036", +"input": "\u0036", +"output": [["Character", "\u0036"]]}, + +{"description": "Valid Unicode character U+0037", +"input": "\u0037", +"output": [["Character", "\u0037"]]}, + +{"description": "Valid Unicode character U+0038", +"input": "\u0038", +"output": [["Character", "\u0038"]]}, + +{"description": "Valid Unicode character U+0039", +"input": "\u0039", +"output": [["Character", "\u0039"]]}, + +{"description": "Valid Unicode character U+003A", +"input": "\u003A", +"output": [["Character", "\u003A"]]}, + +{"description": "Valid Unicode character U+003B", +"input": "\u003B", +"output": [["Character", "\u003B"]]}, + +{"description": "Valid Unicode character U+003D", +"input": "\u003D", +"output": [["Character", "\u003D"]]}, + +{"description": "Valid Unicode character U+003E", +"input": "\u003E", +"output": [["Character", "\u003E"]]}, + +{"description": "Valid Unicode character U+003F", +"input": "\u003F", +"output": [["Character", "\u003F"]]}, + +{"description": "Valid Unicode character U+0040", +"input": "\u0040", +"output": [["Character", "\u0040"]]}, + +{"description": "Valid Unicode character U+0041", +"input": "\u0041", +"output": [["Character", "\u0041"]]}, + +{"description": "Valid Unicode character U+0042", +"input": "\u0042", +"output": [["Character", "\u0042"]]}, + +{"description": "Valid Unicode character U+0043", +"input": "\u0043", +"output": [["Character", "\u0043"]]}, + +{"description": "Valid Unicode character U+0044", +"input": "\u0044", +"output": [["Character", "\u0044"]]}, + +{"description": "Valid Unicode character U+0045", +"input": "\u0045", +"output": [["Character", "\u0045"]]}, + +{"description": "Valid Unicode character U+0046", +"input": "\u0046", +"output": [["Character", "\u0046"]]}, + +{"description": "Valid Unicode character U+0047", +"input": "\u0047", +"output": [["Character", "\u0047"]]}, + +{"description": "Valid Unicode character U+0048", +"input": "\u0048", +"output": [["Character", "\u0048"]]}, + +{"description": "Valid Unicode character U+0049", +"input": "\u0049", +"output": [["Character", "\u0049"]]}, + +{"description": "Valid Unicode character U+004A", +"input": "\u004A", +"output": [["Character", "\u004A"]]}, + +{"description": "Valid Unicode character U+004B", +"input": "\u004B", +"output": [["Character", "\u004B"]]}, + +{"description": "Valid Unicode character U+004C", +"input": "\u004C", +"output": [["Character", "\u004C"]]}, + +{"description": "Valid Unicode character U+004D", +"input": "\u004D", +"output": [["Character", "\u004D"]]}, + +{"description": "Valid Unicode character U+004E", +"input": "\u004E", +"output": [["Character", "\u004E"]]}, + +{"description": "Valid Unicode character U+004F", +"input": "\u004F", +"output": [["Character", "\u004F"]]}, + +{"description": "Valid Unicode character U+0050", +"input": "\u0050", +"output": [["Character", "\u0050"]]}, + +{"description": "Valid Unicode character U+0051", +"input": "\u0051", +"output": [["Character", "\u0051"]]}, + +{"description": "Valid Unicode character U+0052", +"input": "\u0052", +"output": [["Character", "\u0052"]]}, + +{"description": "Valid Unicode character U+0053", +"input": "\u0053", +"output": [["Character", "\u0053"]]}, + +{"description": "Valid Unicode character U+0054", +"input": "\u0054", +"output": [["Character", "\u0054"]]}, + +{"description": "Valid Unicode character U+0055", +"input": "\u0055", +"output": [["Character", "\u0055"]]}, + +{"description": "Valid Unicode character U+0056", +"input": "\u0056", +"output": [["Character", "\u0056"]]}, + +{"description": "Valid Unicode character U+0057", +"input": "\u0057", +"output": [["Character", "\u0057"]]}, + +{"description": "Valid Unicode character U+0058", +"input": "\u0058", +"output": [["Character", "\u0058"]]}, + +{"description": "Valid Unicode character U+0059", +"input": "\u0059", +"output": [["Character", "\u0059"]]}, + +{"description": "Valid Unicode character U+005A", +"input": "\u005A", +"output": [["Character", "\u005A"]]}, + +{"description": "Valid Unicode character U+005B", +"input": "\u005B", +"output": [["Character", "\u005B"]]}, + +{"description": "Valid Unicode character U+005C", +"input": "\u005C", +"output": [["Character", "\u005C"]]}, + +{"description": "Valid Unicode character U+005D", +"input": "\u005D", +"output": [["Character", "\u005D"]]}, + +{"description": "Valid Unicode character U+005E", +"input": "\u005E", +"output": [["Character", "\u005E"]]}, + +{"description": "Valid Unicode character U+005F", +"input": "\u005F", +"output": [["Character", "\u005F"]]}, + +{"description": "Valid Unicode character U+0060", +"input": "\u0060", +"output": [["Character", "\u0060"]]}, + +{"description": "Valid Unicode character U+0061", +"input": "\u0061", +"output": [["Character", "\u0061"]]}, + +{"description": "Valid Unicode character U+0062", +"input": "\u0062", +"output": [["Character", "\u0062"]]}, + +{"description": "Valid Unicode character U+0063", +"input": "\u0063", +"output": [["Character", "\u0063"]]}, + +{"description": "Valid Unicode character U+0064", +"input": "\u0064", +"output": [["Character", "\u0064"]]}, + +{"description": "Valid Unicode character U+0065", +"input": "\u0065", +"output": [["Character", "\u0065"]]}, + +{"description": "Valid Unicode character U+0066", +"input": "\u0066", +"output": [["Character", "\u0066"]]}, + +{"description": "Valid Unicode character U+0067", +"input": "\u0067", +"output": [["Character", "\u0067"]]}, + +{"description": "Valid Unicode character U+0068", +"input": "\u0068", +"output": [["Character", "\u0068"]]}, + +{"description": "Valid Unicode character U+0069", +"input": "\u0069", +"output": [["Character", "\u0069"]]}, + +{"description": "Valid Unicode character U+006A", +"input": "\u006A", +"output": [["Character", "\u006A"]]}, + +{"description": "Valid Unicode character U+006B", +"input": "\u006B", +"output": [["Character", "\u006B"]]}, + +{"description": "Valid Unicode character U+006C", +"input": "\u006C", +"output": [["Character", "\u006C"]]}, + +{"description": "Valid Unicode character U+006D", +"input": "\u006D", +"output": [["Character", "\u006D"]]}, + +{"description": "Valid Unicode character U+006E", +"input": "\u006E", +"output": [["Character", "\u006E"]]}, + +{"description": "Valid Unicode character U+006F", +"input": "\u006F", +"output": [["Character", "\u006F"]]}, + +{"description": "Valid Unicode character U+0070", +"input": "\u0070", +"output": [["Character", "\u0070"]]}, + +{"description": "Valid Unicode character U+0071", +"input": "\u0071", +"output": [["Character", "\u0071"]]}, + +{"description": "Valid Unicode character U+0072", +"input": "\u0072", +"output": [["Character", "\u0072"]]}, + +{"description": "Valid Unicode character U+0073", +"input": "\u0073", +"output": [["Character", "\u0073"]]}, + +{"description": "Valid Unicode character U+0074", +"input": "\u0074", +"output": [["Character", "\u0074"]]}, + +{"description": "Valid Unicode character U+0075", +"input": "\u0075", +"output": [["Character", "\u0075"]]}, + +{"description": "Valid Unicode character U+0076", +"input": "\u0076", +"output": [["Character", "\u0076"]]}, + +{"description": "Valid Unicode character U+0077", +"input": "\u0077", +"output": [["Character", "\u0077"]]}, + +{"description": "Valid Unicode character U+0078", +"input": "\u0078", +"output": [["Character", "\u0078"]]}, + +{"description": "Valid Unicode character U+0079", +"input": "\u0079", +"output": [["Character", "\u0079"]]}, + +{"description": "Valid Unicode character U+007A", +"input": "\u007A", +"output": [["Character", "\u007A"]]}, + +{"description": "Valid Unicode character U+007B", +"input": "\u007B", +"output": [["Character", "\u007B"]]}, + +{"description": "Valid Unicode character U+007C", +"input": "\u007C", +"output": [["Character", "\u007C"]]}, + +{"description": "Valid Unicode character U+007D", +"input": "\u007D", +"output": [["Character", "\u007D"]]}, + +{"description": "Valid Unicode character U+007E", +"input": "\u007E", +"output": [["Character", "\u007E"]]}, + +{"description": "Valid Unicode character U+00A0", +"input": "\u00A0", +"output": [["Character", "\u00A0"]]}, + +{"description": "Valid Unicode character U+00A1", +"input": "\u00A1", +"output": [["Character", "\u00A1"]]}, + +{"description": "Valid Unicode character U+00A2", +"input": "\u00A2", +"output": [["Character", "\u00A2"]]}, + +{"description": "Valid Unicode character U+00A3", +"input": "\u00A3", +"output": [["Character", "\u00A3"]]}, + +{"description": "Valid Unicode character U+00A4", +"input": "\u00A4", +"output": [["Character", "\u00A4"]]}, + +{"description": "Valid Unicode character U+00A5", +"input": "\u00A5", +"output": [["Character", "\u00A5"]]}, + +{"description": "Valid Unicode character U+00A6", +"input": "\u00A6", +"output": [["Character", "\u00A6"]]}, + +{"description": "Valid Unicode character U+00A7", +"input": "\u00A7", +"output": [["Character", "\u00A7"]]}, + +{"description": "Valid Unicode character U+00A8", +"input": "\u00A8", +"output": [["Character", "\u00A8"]]}, + +{"description": "Valid Unicode character U+00A9", +"input": "\u00A9", +"output": [["Character", "\u00A9"]]}, + +{"description": "Valid Unicode character U+00AA", +"input": "\u00AA", +"output": [["Character", "\u00AA"]]}, + +{"description": "Valid Unicode character U+00AB", +"input": "\u00AB", +"output": [["Character", "\u00AB"]]}, + +{"description": "Valid Unicode character U+00AC", +"input": "\u00AC", +"output": [["Character", "\u00AC"]]}, + +{"description": "Valid Unicode character U+00AD", +"input": "\u00AD", +"output": [["Character", "\u00AD"]]}, + +{"description": "Valid Unicode character U+00AE", +"input": "\u00AE", +"output": [["Character", "\u00AE"]]}, + +{"description": "Valid Unicode character U+00AF", +"input": "\u00AF", +"output": [["Character", "\u00AF"]]}, + +{"description": "Valid Unicode character U+00B0", +"input": "\u00B0", +"output": [["Character", "\u00B0"]]}, + +{"description": "Valid Unicode character U+00B1", +"input": "\u00B1", +"output": [["Character", "\u00B1"]]}, + +{"description": "Valid Unicode character U+00B2", +"input": "\u00B2", +"output": [["Character", "\u00B2"]]}, + +{"description": "Valid Unicode character U+00B3", +"input": "\u00B3", +"output": [["Character", "\u00B3"]]}, + +{"description": "Valid Unicode character U+00B4", +"input": "\u00B4", +"output": [["Character", "\u00B4"]]}, + +{"description": "Valid Unicode character U+00B5", +"input": "\u00B5", +"output": [["Character", "\u00B5"]]}, + +{"description": "Valid Unicode character U+00B6", +"input": "\u00B6", +"output": [["Character", "\u00B6"]]}, + +{"description": "Valid Unicode character U+00B7", +"input": "\u00B7", +"output": [["Character", "\u00B7"]]}, + +{"description": "Valid Unicode character U+00B8", +"input": "\u00B8", +"output": [["Character", "\u00B8"]]}, + +{"description": "Valid Unicode character U+00B9", +"input": "\u00B9", +"output": [["Character", "\u00B9"]]}, + +{"description": "Valid Unicode character U+00BA", +"input": "\u00BA", +"output": [["Character", "\u00BA"]]}, + +{"description": "Valid Unicode character U+00BB", +"input": "\u00BB", +"output": [["Character", "\u00BB"]]}, + +{"description": "Valid Unicode character U+00BC", +"input": "\u00BC", +"output": [["Character", "\u00BC"]]}, + +{"description": "Valid Unicode character U+00BD", +"input": "\u00BD", +"output": [["Character", "\u00BD"]]}, + +{"description": "Valid Unicode character U+00BE", +"input": "\u00BE", +"output": [["Character", "\u00BE"]]}, + +{"description": "Valid Unicode character U+00BF", +"input": "\u00BF", +"output": [["Character", "\u00BF"]]}, + +{"description": "Valid Unicode character U+00C0", +"input": "\u00C0", +"output": [["Character", "\u00C0"]]}, + +{"description": "Valid Unicode character U+00C1", +"input": "\u00C1", +"output": [["Character", "\u00C1"]]}, + +{"description": "Valid Unicode character U+00C2", +"input": "\u00C2", +"output": [["Character", "\u00C2"]]}, + +{"description": "Valid Unicode character U+00C3", +"input": "\u00C3", +"output": [["Character", "\u00C3"]]}, + +{"description": "Valid Unicode character U+00C4", +"input": "\u00C4", +"output": [["Character", "\u00C4"]]}, + +{"description": "Valid Unicode character U+00C5", +"input": "\u00C5", +"output": [["Character", "\u00C5"]]}, + +{"description": "Valid Unicode character U+00C6", +"input": "\u00C6", +"output": [["Character", "\u00C6"]]}, + +{"description": "Valid Unicode character U+00C7", +"input": "\u00C7", +"output": [["Character", "\u00C7"]]}, + +{"description": "Valid Unicode character U+00C8", +"input": "\u00C8", +"output": [["Character", "\u00C8"]]}, + +{"description": "Valid Unicode character U+00C9", +"input": "\u00C9", +"output": [["Character", "\u00C9"]]}, + +{"description": "Valid Unicode character U+00CA", +"input": "\u00CA", +"output": [["Character", "\u00CA"]]}, + +{"description": "Valid Unicode character U+00CB", +"input": "\u00CB", +"output": [["Character", "\u00CB"]]}, + +{"description": "Valid Unicode character U+00CC", +"input": "\u00CC", +"output": [["Character", "\u00CC"]]}, + +{"description": "Valid Unicode character U+00CD", +"input": "\u00CD", +"output": [["Character", "\u00CD"]]}, + +{"description": "Valid Unicode character U+00CE", +"input": "\u00CE", +"output": [["Character", "\u00CE"]]}, + +{"description": "Valid Unicode character U+00CF", +"input": "\u00CF", +"output": [["Character", "\u00CF"]]}, + +{"description": "Valid Unicode character U+00D0", +"input": "\u00D0", +"output": [["Character", "\u00D0"]]}, + +{"description": "Valid Unicode character U+00D1", +"input": "\u00D1", +"output": [["Character", "\u00D1"]]}, + +{"description": "Valid Unicode character U+00D2", +"input": "\u00D2", +"output": [["Character", "\u00D2"]]}, + +{"description": "Valid Unicode character U+00D3", +"input": "\u00D3", +"output": [["Character", "\u00D3"]]}, + +{"description": "Valid Unicode character U+00D4", +"input": "\u00D4", +"output": [["Character", "\u00D4"]]}, + +{"description": "Valid Unicode character U+00D5", +"input": "\u00D5", +"output": [["Character", "\u00D5"]]}, + +{"description": "Valid Unicode character U+00D6", +"input": "\u00D6", +"output": [["Character", "\u00D6"]]}, + +{"description": "Valid Unicode character U+00D7", +"input": "\u00D7", +"output": [["Character", "\u00D7"]]}, + +{"description": "Valid Unicode character U+00D8", +"input": "\u00D8", +"output": [["Character", "\u00D8"]]}, + +{"description": "Valid Unicode character U+00D9", +"input": "\u00D9", +"output": [["Character", "\u00D9"]]}, + +{"description": "Valid Unicode character U+00DA", +"input": "\u00DA", +"output": [["Character", "\u00DA"]]}, + +{"description": "Valid Unicode character U+00DB", +"input": "\u00DB", +"output": [["Character", "\u00DB"]]}, + +{"description": "Valid Unicode character U+00DC", +"input": "\u00DC", +"output": [["Character", "\u00DC"]]}, + +{"description": "Valid Unicode character U+00DD", +"input": "\u00DD", +"output": [["Character", "\u00DD"]]}, + +{"description": "Valid Unicode character U+00DE", +"input": "\u00DE", +"output": [["Character", "\u00DE"]]}, + +{"description": "Valid Unicode character U+00DF", +"input": "\u00DF", +"output": [["Character", "\u00DF"]]}, + +{"description": "Valid Unicode character U+00E0", +"input": "\u00E0", +"output": [["Character", "\u00E0"]]}, + +{"description": "Valid Unicode character U+00E1", +"input": "\u00E1", +"output": [["Character", "\u00E1"]]}, + +{"description": "Valid Unicode character U+00E2", +"input": "\u00E2", +"output": [["Character", "\u00E2"]]}, + +{"description": "Valid Unicode character U+00E3", +"input": "\u00E3", +"output": [["Character", "\u00E3"]]}, + +{"description": "Valid Unicode character U+00E4", +"input": "\u00E4", +"output": [["Character", "\u00E4"]]}, + +{"description": "Valid Unicode character U+00E5", +"input": "\u00E5", +"output": [["Character", "\u00E5"]]}, + +{"description": "Valid Unicode character U+00E6", +"input": "\u00E6", +"output": [["Character", "\u00E6"]]}, + +{"description": "Valid Unicode character U+00E7", +"input": "\u00E7", +"output": [["Character", "\u00E7"]]}, + +{"description": "Valid Unicode character U+00E8", +"input": "\u00E8", +"output": [["Character", "\u00E8"]]}, + +{"description": "Valid Unicode character U+00E9", +"input": "\u00E9", +"output": [["Character", "\u00E9"]]}, + +{"description": "Valid Unicode character U+00EA", +"input": "\u00EA", +"output": [["Character", "\u00EA"]]}, + +{"description": "Valid Unicode character U+00EB", +"input": "\u00EB", +"output": [["Character", "\u00EB"]]}, + +{"description": "Valid Unicode character U+00EC", +"input": "\u00EC", +"output": [["Character", "\u00EC"]]}, + +{"description": "Valid Unicode character U+00ED", +"input": "\u00ED", +"output": [["Character", "\u00ED"]]}, + +{"description": "Valid Unicode character U+00EE", +"input": "\u00EE", +"output": [["Character", "\u00EE"]]}, + +{"description": "Valid Unicode character U+00EF", +"input": "\u00EF", +"output": [["Character", "\u00EF"]]}, + +{"description": "Valid Unicode character U+00F0", +"input": "\u00F0", +"output": [["Character", "\u00F0"]]}, + +{"description": "Valid Unicode character U+00F1", +"input": "\u00F1", +"output": [["Character", "\u00F1"]]}, + +{"description": "Valid Unicode character U+00F2", +"input": "\u00F2", +"output": [["Character", "\u00F2"]]}, + +{"description": "Valid Unicode character U+00F3", +"input": "\u00F3", +"output": [["Character", "\u00F3"]]}, + +{"description": "Valid Unicode character U+00F4", +"input": "\u00F4", +"output": [["Character", "\u00F4"]]}, + +{"description": "Valid Unicode character U+00F5", +"input": "\u00F5", +"output": [["Character", "\u00F5"]]}, + +{"description": "Valid Unicode character U+00F6", +"input": "\u00F6", +"output": [["Character", "\u00F6"]]}, + +{"description": "Valid Unicode character U+00F7", +"input": "\u00F7", +"output": [["Character", "\u00F7"]]}, + +{"description": "Valid Unicode character U+00F8", +"input": "\u00F8", +"output": [["Character", "\u00F8"]]}, + +{"description": "Valid Unicode character U+00F9", +"input": "\u00F9", +"output": [["Character", "\u00F9"]]}, + +{"description": "Valid Unicode character U+00FA", +"input": "\u00FA", +"output": [["Character", "\u00FA"]]}, + +{"description": "Valid Unicode character U+00FB", +"input": "\u00FB", +"output": [["Character", "\u00FB"]]}, + +{"description": "Valid Unicode character U+00FC", +"input": "\u00FC", +"output": [["Character", "\u00FC"]]}, + +{"description": "Valid Unicode character U+00FD", +"input": "\u00FD", +"output": [["Character", "\u00FD"]]}, + +{"description": "Valid Unicode character U+00FE", +"input": "\u00FE", +"output": [["Character", "\u00FE"]]}, + +{"description": "Valid Unicode character U+00FF", +"input": "\u00FF", +"output": [["Character", "\u00FF"]]}, + +{"description": "Valid Unicode character U+D7FF", +"input": "\uD7FF", +"output": [["Character", "\uD7FF"]]}, + +{"description": "Valid Unicode character U+E000", +"input": "\uE000", +"output": [["Character", "\uE000"]]}, + +{"description": "Valid Unicode character U+FDCF", +"input": "\uFDCF", +"output": [["Character", "\uFDCF"]]}, + +{"description": "Valid Unicode character U+FDF0", +"input": "\uFDF0", +"output": [["Character", "\uFDF0"]]}, + +{"description": "Valid Unicode character U+FFFD", +"input": "\uFFFD", +"output": [["Character", "\uFFFD"]]}, + +{"description": "Valid Unicode character U+10000", +"input": "\uD800\uDC00", +"output": [["Character", "\uD800\uDC00"]]}, + +{"description": "Valid Unicode character U+1FFFD", +"input": "\uD83F\uDFFD", +"output": [["Character", "\uD83F\uDFFD"]]}, + +{"description": "Valid Unicode character U+20000", +"input": "\uD840\uDC00", +"output": [["Character", "\uD840\uDC00"]]}, + +{"description": "Valid Unicode character U+2FFFD", +"input": "\uD87F\uDFFD", +"output": [["Character", "\uD87F\uDFFD"]]}, + +{"description": "Valid Unicode character U+30000", +"input": "\uD880\uDC00", +"output": [["Character", "\uD880\uDC00"]]}, + +{"description": "Valid Unicode character U+3FFFD", +"input": "\uD8BF\uDFFD", +"output": [["Character", "\uD8BF\uDFFD"]]}, + +{"description": "Valid Unicode character U+40000", +"input": "\uD8C0\uDC00", +"output": [["Character", "\uD8C0\uDC00"]]}, + +{"description": "Valid Unicode character U+4FFFD", +"input": "\uD8FF\uDFFD", +"output": [["Character", "\uD8FF\uDFFD"]]}, + +{"description": "Valid Unicode character U+50000", +"input": "\uD900\uDC00", +"output": [["Character", "\uD900\uDC00"]]}, + +{"description": "Valid Unicode character U+5FFFD", +"input": "\uD93F\uDFFD", +"output": [["Character", "\uD93F\uDFFD"]]}, + +{"description": "Valid Unicode character U+60000", +"input": "\uD940\uDC00", +"output": [["Character", "\uD940\uDC00"]]}, + +{"description": "Valid Unicode character U+6FFFD", +"input": "\uD97F\uDFFD", +"output": [["Character", "\uD97F\uDFFD"]]}, + +{"description": "Valid Unicode character U+70000", +"input": "\uD980\uDC00", +"output": [["Character", "\uD980\uDC00"]]}, + +{"description": "Valid Unicode character U+7FFFD", +"input": "\uD9BF\uDFFD", +"output": [["Character", "\uD9BF\uDFFD"]]}, + +{"description": "Valid Unicode character U+80000", +"input": "\uD9C0\uDC00", +"output": [["Character", "\uD9C0\uDC00"]]}, + +{"description": "Valid Unicode character U+8FFFD", +"input": "\uD9FF\uDFFD", +"output": [["Character", "\uD9FF\uDFFD"]]}, + +{"description": "Valid Unicode character U+90000", +"input": "\uDA00\uDC00", +"output": [["Character", "\uDA00\uDC00"]]}, + +{"description": "Valid Unicode character U+9FFFD", +"input": "\uDA3F\uDFFD", +"output": [["Character", "\uDA3F\uDFFD"]]}, + +{"description": "Valid Unicode character U+A0000", +"input": "\uDA40\uDC00", +"output": [["Character", "\uDA40\uDC00"]]}, + +{"description": "Valid Unicode character U+AFFFD", +"input": "\uDA7F\uDFFD", +"output": [["Character", "\uDA7F\uDFFD"]]}, + +{"description": "Valid Unicode character U+B0000", +"input": "\uDA80\uDC00", +"output": [["Character", "\uDA80\uDC00"]]}, + +{"description": "Valid Unicode character U+BFFFD", +"input": "\uDABF\uDFFD", +"output": [["Character", "\uDABF\uDFFD"]]}, + +{"description": "Valid Unicode character U+C0000", +"input": "\uDAC0\uDC00", +"output": [["Character", "\uDAC0\uDC00"]]}, + +{"description": "Valid Unicode character U+CFFFD", +"input": "\uDAFF\uDFFD", +"output": [["Character", "\uDAFF\uDFFD"]]}, + +{"description": "Valid Unicode character U+D0000", +"input": "\uDB00\uDC00", +"output": [["Character", "\uDB00\uDC00"]]}, + +{"description": "Valid Unicode character U+DFFFD", +"input": "\uDB3F\uDFFD", +"output": [["Character", "\uDB3F\uDFFD"]]}, + +{"description": "Valid Unicode character U+E0000", +"input": "\uDB40\uDC00", +"output": [["Character", "\uDB40\uDC00"]]}, + +{"description": "Valid Unicode character U+EFFFD", +"input": "\uDB7F\uDFFD", +"output": [["Character", "\uDB7F\uDFFD"]]}, + +{"description": "Valid Unicode character U+F0000", +"input": "\uDB80\uDC00", +"output": [["Character", "\uDB80\uDC00"]]}, + +{"description": "Valid Unicode character U+FFFFD", +"input": "\uDBBF\uDFFD", +"output": [["Character", "\uDBBF\uDFFD"]]}, + +{"description": "Valid Unicode character U+100000", +"input": "\uDBC0\uDC00", +"output": [["Character", "\uDBC0\uDC00"]]}, + +{"description": "Valid Unicode character U+10FFFD", +"input": "\uDBFF\uDFFD", +"output": [["Character", "\uDBFF\uDFFD"]]} + +]} diff --git a/tests/data/tokenizer/unicodeCharsProblematic.test b/tests/data/tokenizer/unicodeCharsProblematic.test new file mode 100644 index 0000000..cf2fbe6 --- /dev/null +++ b/tests/data/tokenizer/unicodeCharsProblematic.test @@ -0,0 +1,27 @@ +{"tests" : [ +{"description": "Invalid Unicode character U+DFFF", +"doubleEscaped":true, +"input": "\\uDFFF", +"output":["ParseError", ["Character", "\\uFFFD"]]}, + +{"description": "Invalid Unicode character U+D800", +"doubleEscaped":true, +"input": "\\uD800", +"output":["ParseError", ["Character", "\\uFFFD"]]}, + +{"description": "Invalid Unicode character U+DFFF with valid preceding character", +"doubleEscaped":true, +"input": "a\\uDFFF", +"output":["ParseError", ["Character", "a\\uFFFD"]]}, + +{"description": "Invalid Unicode character U+D800 with valid following character", +"doubleEscaped":true, +"input": "\\uD800a", +"output":["ParseError", ["Character", "\\uFFFDa"]]}, + +{"description":"CR followed by U+0000", +"input":"\r\u0000", +"output":[["Character", "\n"], "ParseError", ["Character", "\u0000"]], +"ignoreErrorOrder":true} +] +} \ No newline at end of file diff --git a/tests/data/tokenizer/xmlViolation.test b/tests/data/tokenizer/xmlViolation.test new file mode 100644 index 0000000..137d964 --- /dev/null +++ b/tests/data/tokenizer/xmlViolation.test @@ -0,0 +1,22 @@ +{"xmlViolationTests": [ + +{"description":"Non-XML character", +"input":"a\uFFFFb", +"ignoreErrorOrder":true, +"output":["ParseError",["Character","a\uFFFDb"]]}, + +{"description":"Non-XML space", +"input":"a\u000Cb", +"ignoreErrorOrder":true, +"output":[["Character","a b"]]}, + +{"description":"Double hyphen in comment", +"input":"<!-- foo -- bar -->", +"output":["ParseError",["Comment"," foo - - bar "]]}, + +{"description":"FF between attributes", +"input":"<a b=''\u000Cc=''>", +"output":[["StartTag","a",{"b":"","c":""}]]} +]} + + diff --git a/tests/run.sh b/tests/run.sh new file mode 100755 index 0000000..ffdf164 --- /dev/null +++ b/tests/run.sh @@ -0,0 +1,17 @@ +#!/bin/bash +# Copyright (c) 2012, the Dart project authors. Please see the AUTHORS file +# for details. All rights reserved. Use of this source code is governed by a +# BSD-style license that can be found in the LICENSE file. + +# Script to run all tests in the webcomponents package. For this script to run +# correctly, you need to have a SDK installation and set the following +# environment variable: +# > export DART_SDK=<SDK location> +# +# If you already have a dart_lang checkout, you can build the SDK directly. + +DART=$DART_SDK/bin/dart +# TODO(sigmund): generalize to run browser tests too +for test in tests/*_test.dart; do + $DART --enable-asserts --enable-type-checks --package-root=packages/ $test +done diff --git a/tests/support.dart b/tests/support.dart new file mode 100644 index 0000000..4ac6afc --- /dev/null +++ b/tests/support.dart @@ -0,0 +1,24 @@ +#library('support'); +#import('dart:io'); + +final testDataDir = ''; + +typedef bool FileMatcher(String fileName); + +Future<List<String>> getDataFiles(String subdirectory, [FileMatcher matcher]) { + if (matcher == null) matcher = (path) => path.endsWith('.dat'); + + // TODO(jmesserly): should have listSync for scripting... + // This entire method was one line of Python code + var dir = new Directory.fromPath(new Path('tests/data/$subdirectory')); + var lister = dir.list(); + var files = <String>[]; + lister.onFile = (file) { + if (matcher(file)) files.add(file); + }; + var completer = new Completer<List<String>>(); + lister.onDone = (success) { + completer.complete(files); + }; + return completer.future; +} diff --git a/tests/tokenizer_test.dart b/tests/tokenizer_test.dart new file mode 100644 index 0000000..47de0c2 --- /dev/null +++ b/tests/tokenizer_test.dart @@ -0,0 +1,324 @@ +#library('tokenizer_test'); + +// Note: mirrors used to match the getattr usage in the original test +#import('dart:io'); +#import('dart:json'); +#import('dart:mirrors'); +#import('package:unittest/unittest.dart'); +#import('../tokenizer.dart'); +#import('../constants.dart', prefix: 'constants'); +#import('../codecs.dart'); +#import('support.dart'); + +main() { + testTokenizer(); +} + +/** + * This is like [JSON.parse], but it fixes unicode surrogate pairs in the JSON. + * + * Without this, the test "expects" incorrect results from the tokenizer. + * Note: Python's json module decodes these correctly, so this might point at + * a bug in Dart's [JSON.parse]. + */ +jsonParseUnicode(String input) => jsonFixSurrogatePairs(JSON.parse(input)); + +// TODO(jmesserly): this should probably be handled by dart:json +jsonFixSurrogatePairs(jsonObject) { + fixSurrogate(object) { + if (object is String) { + return decodeUtf16Surrogates(object); + } else if (object is List) { + List a = object; + for (int i = 0; i < a.length; i++) { + a[i] = fixSurrogate(a[i]); + } + } else if (object is Map) { + Map<String, Object> m = object; + m.forEach((key, value) { + var fixedKey = fixSurrogate(key); + var fixedValue = fixSurrogate(value); + if (fixedKey !== key) { + m.remove(key); + m[fixedKey] = fixedValue; + } else if (fixedValue !== value) { + m[fixedKey] = fixedValue; + } + }); + } + return object; + } + return fixSurrogate(jsonObject); +} + + +class TokenizerTestParser { + String _state; + var _lastStartTag; + List outputTokens; + + TokenizerTestParser(String initialState, [lastStartTag]) + : _state = initialState, + _lastStartTag = lastStartTag; + + List parse(stream, [encoding, innerHTML = false]) { + var tokenizer = new HTMLTokenizer(stream, encoding); + outputTokens = []; + + // Note: we can't get a closure of the state method. However, we can + // create a new closure to invoke it via mirrors. + var mirrors = currentMirrorSystem(); + var mtok = mirrors.mirrorOf(tokenizer); + // TODO(jmesserly): mirrors are causing us to lose stack traces? + // If you hit a bug and aren't getting a stack trace, consider adding + // debug code like this to avoid the mirror invocation: + // if (_state == 'dataState') { + // tokenizer.state = tokenizer.dataState; + // } else { + // Replace 'dataState' with the appropriate state name. + tokenizer.state = () => mtok.invoke(_state, const []).value.reflectee; + + if (_lastStartTag != null) { + tokenizer.currentToken = {"type": "startTag", "name": _lastStartTag}; + } + + var types = new Map<int, String>(); + constants.tokenTypes.forEach((k, v) => types[v] = k); + while (tokenizer.hasNext()) { + var token = tokenizer.next(); + mirrors.mirrorOf(this).invoke( + 'process${types[token["type"]]}', [mirrors.mirrorOf(token)]); + } + + return outputTokens; + } + + /** Makes a dictionary, where the first key wins. */ + Map _makeDict(List<List> items) { + var result = new Map(); + for (var item in items) { + expect(item.length, equals(2)); + result.putIfAbsent(item[0], () => item[1]); + } + return result; + } + + void processDoctype(Map token) { + outputTokens.add(["DOCTYPE", token["name"], token["publicId"], + token["systemId"], token["correct"]]); + } + + void processStartTag(Map token) { + outputTokens.add(["StartTag", token["name"], + _makeDict(token["data"]), token["selfClosing"]]); + } + + void processEmptyTag(Map token) { + if (constants.voidElements.indexOf(token["name"]) >= 0) { + outputTokens.add("ParseError"); + } + outputTokens.add(["StartTag", token["name"], _makeDict(token["data"])]); + } + + void processEndTag(Map token) { + outputTokens.add(["EndTag", token["name"], token["selfClosing"]]); + } + + void processComment(Map token) { + outputTokens.add(["Comment", token["data"]]); + } + + void processSpaceCharacters(Map token) { + processCharacters(token); + } + + void processCharacters(Map token) { + outputTokens.add(["Character", token["data"]]); + } + + void processEOF(token) { + } + + void processParseError(Map token) { + // TODO(jmesserly): when debugging test failures it can be useful to add + // logging here like `print('ParseError $token');`. It would be nice to + // use the actual logging library. + outputTokens.add(["ParseError", token["data"]]); + } +} + +List concatenateCharacterTokens(List tokens) { + var outputTokens = []; + for (var token in tokens) { + if (token.indexOf("ParseError") == -1 && token[0] == "Character") { + if (outputTokens.length > 0 && + outputTokens.last().indexOf("ParseError") == -1 && + outputTokens.last()[0] == "Character") { + + outputTokens.last()[1] = '${outputTokens.last()[1]}${token[1]}'; + } else { + outputTokens.add(token); + } + } else { + outputTokens.add(token); + } + } + return outputTokens; +} + +List normalizeTokens(List tokens) { + // TODO: convert tests to reflect arrays + for (int i = 0; i < tokens.length; i++) { + var token = tokens[i]; + if (token[0] == 'ParseError') { + tokens[i] = token[0]; + } + } + return tokens; +} + + +/** + * Test whether the test has passed or failed + * + * If the ignoreErrorOrder flag is set to true we don't test the relative + * positions of parse errors and non parse errors. + */ +void expectTokensMatch(List expectedTokens, List receivedTokens, + bool ignoreErrorOrder, [bool ignoreErrors = false, String message]) { + + var checkSelfClosing = false; + for (var token in expectedTokens) { + if (token[0] == "StartTag" && token.length == 4 + || token[0] == "EndTag" && token.length == 3) { + checkSelfClosing = true; + break; + } + } + + if (!checkSelfClosing) { + for (var token in receivedTokens) { + if (token[0] == "StartTag" || token[0] == "EndTag") { + token.removeLast(); + } + } + } + + if (!ignoreErrorOrder && !ignoreErrors) { + expect(receivedTokens, equals(expectedTokens), message); + } else { + // Sort the tokens into two groups; non-parse errors and parse errors + var expectedParseErrors = expectedTokens.filter((t) => t == "ParseError"); + var expectedNonErrors = expectedTokens.filter((t) => t != "ParseError"); + var receivedParseErrors = receivedTokens.filter((t) => t == "ParseError"); + var receivedNonErrors = receivedTokens.filter((t) => t != "ParseError"); + + expect(receivedNonErrors, equals(expectedNonErrors), message); + if (!ignoreErrors) { + expect(receivedParseErrors, equals(expectedParseErrors), message); + } + } +} + +// TODO(jmesserly): I had to use this trampoline to get reasonable stack traces +// from the unit test framework. +/* +void runTokenizerTest(Map testInfo) { + try { + runTokenizerTest2(testInfo); + } catch (var e, var trace) { + print('exception $e'); + print('trace $trace'); + exit(1); + } +} +*/ + +void runTokenizerTest(Map testInfo) { + // XXX - move this out into the setup function + // concatenate all consecutive character tokens into a single token + if (testInfo.containsKey('doubleEscaped')) { + testInfo = unescape(testInfo); + } + + var expected = concatenateCharacterTokens(testInfo['output']); + if (!testInfo.containsKey('lastStartTag')) { + testInfo['lastStartTag'] = null; + } + var parser = new TokenizerTestParser(testInfo['initialState'], + testInfo['lastStartTag']); + var tokens = parser.parse(testInfo['input']); + tokens = concatenateCharacterTokens(tokens); + var received = normalizeTokens(tokens); + var errorMsg = Strings.join(["\n\nInitial state:", + testInfo['initialState'], + "\nInput:", testInfo['input'], + "\nExpected:", expected, + "\nreceived:", tokens].map((s) => '$s'), '\n'); + var ignoreErrorOrder = testInfo['ignoreErrorOrder']; + if (ignoreErrorOrder == null) ignoreErrorOrder = false; + + expectTokensMatch(expected, received, ignoreErrorOrder, true, errorMsg); +} + +Map unescape(Map testInfo) { + // Note: using JSON.parse to unescape the unicode characters in the string. + decode(inp) => jsonParseUnicode('"${inp}"'); + + testInfo["input"] = decode(testInfo["input"]); + for (var token in testInfo["output"]) { + if (token == "ParseError") { + continue; + } else { + token[1] = decode(token[1]); + if (token.length > 2) { + for (var pair in token[2]) { + var key = pair[0]; + var value = pair[1]; + token[2].remove(key); + token[2][decode(key)] = decode(value); + } + } + } + } + return testInfo; +} + + +String camelCase(String s) { + s = s.toLowerCase(); + var result = new StringBuffer(); + for (var match in const RegExp(@"\W+(\w)(\w+)").allMatches(s)) { + if (result.length == 0) result.add(s.substring(0, match.start())); + result.add(match.group(1).toUpperCase()); + result.add(match.group(2)); + } + return result.toString(); +} + +void testTokenizer() { + getDataFiles('tokenizer', (p) => p.endsWith('.test')).then((files) { + for (var path in files) { + + var text = new File.fromPath(new Path(path)).readAsTextSync(); + var tests = jsonParseUnicode(text); + var testName = new Path.fromNative(path).filename.replaceAll(".test",""); + var testList = tests['tests']; + if (testList == null) continue; + + group(testName, () { + for (int index = 0; index < testList.length; index++) { + final testInfo = testList[index]; + + testInfo.putIfAbsent("initialStates", () => ["Data state"]); + for (var initialState in testInfo["initialStates"]) { + test(testInfo["description"], () { + testInfo["initialState"] = camelCase(initialState); + runTokenizerTest(testInfo); + }); + } + } + }); + } + }); +} diff --git a/tokenizer.dart b/tokenizer.dart new file mode 100644 index 0000000..7bfccf2 --- /dev/null +++ b/tokenizer.dart @@ -0,0 +1,1949 @@ +#library('tokenizer'); + +#import('dart:math'); +#import('constants.dart'); +#import('inputstream.dart'); +#import('utils.dart'); + +// Group entities by their first character, for faster lookups + +Map<String, List<String>> _entitiesByFirstChar; +Map<String, List<String>> get entitiesByFirstChar() { + if (_entitiesByFirstChar == null) { + _entitiesByFirstChar = {}; + for (var k in entities.getKeys()) { + _entitiesByFirstChar.putIfAbsent(k[0], () => []).add(k); + } + } + return _entitiesByFirstChar; +} + +// TODO(jmesserly): lots of ways to make this faster: +// - use char codes everywhere instead of 1-char strings +// - use switch instead of inStr +// - use switch instead of the sequential if tests +// - use an Token class instead of a map for tokens +// - avoid tokenTypes lookup +// - avoid string concat + +/** + * This class takes care of tokenizing HTML. + * + * * [currentToken] + * Holds the token that is currently being processed. + * * [state] + * Holds a reference to the method to be invoked for the next parser state. + * * [stream] + * Points to HTMLInputStream object. + */ +class HTMLTokenizer implements Iterator<Map> { + final HTMLInputStream stream; + final bool lowercaseElementName; + final bool lowercaseAttrName; + final parser; + + Map currentToken; + Predicate state; + List lastFourChars; + bool escapeFlag; + bool escape; + Queue tokenQueue; + String temporaryBuffer; + + HTMLTokenizer(stream, + [String encoding, bool parseMeta = true, + this.lowercaseElementName = true, this.lowercaseAttrName = true, + this.parser]) + : stream = new HTMLInputStream(stream, encoding, parseMeta), + escapeFlag = false, + lastFourChars = [], + escape = false, + tokenQueue = new Queue() { + state = dataState; + } + + get lastData() => currentToken["data"].last(); + + bool hasNext() { + if (stream.errors.length > 0) return true; + if (tokenQueue.length > 0) return true; + // Start processing. When EOF is reached state will return false; + // instead of true and the loop will terminate. + do { + if (!state()) return false; + } while (stream.errors.length == 0 && tokenQueue.length == 0); + return true; + } + + /** + * This is where the magic happens. + * + * We do our usually processing through the states and when we have a token + * to return we yield the token which pauses processing until the next token + * is requested. + */ + Map next() { + if (hasNext()) { + if (stream.errors.length > 0) { + return {"type": tokenTypes["ParseError"], + "data": removeAt(stream.errors, 0)}; + } + return tokenQueue.removeFirst(); + } else { + throw const NoMoreElementsException(); + } + } + + /** + * This function returns either U+FFFD or the character based on the + * decimal or hexadecimal representation. It also discards ";" if present. + * If not present tokenQueue.addLast({"type": tokenTypes["ParseError"]}); + * is invoked. + */ + String consumeNumberEntity(bool isHex) { + var allowed = isDigit; + var radix = 10; + if (isHex) { + allowed = isHexDigit; + radix = 16; + } + + var charStack = []; + + // Consume all the characters that are in range while making sure we + // don't hit an EOF. + var c = stream.char(); + while (allowed(c) && c !== EOF) { + charStack.add(c); + c = stream.char(); + } + + // Convert the set of characters consumed to an int. + var charAsInt = parseIntRadix(joinStr(charStack), radix); + + // Certain characters get replaced with others + var char = replacementCharacters[charAsInt]; + if (char != null) { + tokenQueue.addLast({"type": tokenTypes["ParseError"], "data": + "illegal-codepoint-for-numeric-entity", + "datavars": {"charAsInt": charAsInt}}); + } else if ((0xD800 <= charAsInt && charAsInt <= 0xDFFF) + || (charAsInt > 0x10FFFF)) { + char = "\uFFFD"; + tokenQueue.addLast({"type": tokenTypes["ParseError"], "data": + "illegal-codepoint-for-numeric-entity", + "datavars": {"charAsInt": charAsInt}}); + } else { + // Should speed up this check somehow (e.g. move the set to a constant) + if ((0x0001 <= charAsInt && charAsInt <= 0x0008) || + (0x000E <= charAsInt && charAsInt <= 0x001F) || + (0x007F <= charAsInt && charAsInt <= 0x009F) || + (0xFDD0 <= charAsInt && charAsInt <= 0xFDEF) || + const [0x000B, 0xFFFE, 0xFFFF, 0x1FFFE, + 0x1FFFF, 0x2FFFE, 0x2FFFF, 0x3FFFE, + 0x3FFFF, 0x4FFFE, 0x4FFFF, 0x5FFFE, + 0x5FFFF, 0x6FFFE, 0x6FFFF, 0x7FFFE, + 0x7FFFF, 0x8FFFE, 0x8FFFF, 0x9FFFE, + 0x9FFFF, 0xAFFFE, 0xAFFFF, 0xBFFFE, + 0xBFFFF, 0xCFFFE, 0xCFFFF, 0xDFFFE, + 0xDFFFF, 0xEFFFE, 0xEFFFF, 0xFFFFE, + 0xFFFFF, 0x10FFFE, 0x10FFFF].indexOf(charAsInt) >= 0) { + tokenQueue.addLast({"type": tokenTypes["ParseError"], + "data": "illegal-codepoint-for-numeric-entity", + "datavars": {"charAsInt": charAsInt}}); + } + char = new String.fromCharCodes([charAsInt]); + } + + // Discard the ; if present. Otherwise, put it back on the queue and + // invoke parseError on parser. + if (c != ";") { + tokenQueue.addLast({"type": tokenTypes["ParseError"], "data": + "numeric-entity-without-semicolon"}); + stream.unget(c); + } + return char; + } + + void consumeEntity([String allowedChar, bool fromAttribute = false]) { + // Initialise to the default output for when no entity is matched + var output = "&"; + + var charStack = [stream.char()]; + if (isWhitespace(charStack[0]) || inStr(charStack[0], '<&') + || charStack[0] == EOF || allowedChar == charStack[0]) { + stream.unget(charStack[0]); + } else if (charStack[0] == "#") { + // Read the next character to see if it's hex or decimal + bool hex = false; + charStack.add(stream.char()); + if (charStack.last() == 'x' || charStack.last() == 'X') { + hex = true; + charStack.add(stream.char()); + } + + // charStack.last() should be the first digit + if (hex && isHexDigit(charStack.last()) || + (!hex && isDigit(charStack.last()))) { + // At least one digit found, so consume the whole number + stream.unget(charStack.last()); + output = consumeNumberEntity(hex); + } else { + // No digits found + tokenQueue.addLast({"type": tokenTypes["ParseError"], + "data": "expected-numeric-entity"}); + stream.unget(charStack.removeLast()); + output = "&${joinStr(charStack)}"; + } + } else { + // At this point in the process might have named entity. Entities + // are stored in the global variable "entities". + // + // Consume characters and compare to these to a substring of the + // entity names in the list until the substring no longer matches. + var filteredEntityList = entitiesByFirstChar[charStack[0]]; + if (filteredEntityList == null) filteredEntityList = const []; + + while (charStack.last() !== EOF) { + var name = joinStr(charStack); + filteredEntityList = filteredEntityList.filter( + (e) => e.startsWith(name)); + + if (filteredEntityList.length == 0) { + break; + } + charStack.add(stream.char()); + } + + // At this point we have a string that starts with some characters + // that may match an entity + var entityName = null; + + // Try to find the longest entity the string will match to take care + // of &noti for instance. + + int entityLen; + for (entityLen = charStack.length - 1; entityLen > 1; entityLen--) { + var possibleEntityName = joinStr(charStack.getRange(0, entityLen)); + if (entities.containsKey(possibleEntityName)) { + entityName = possibleEntityName; + break; + } + } + + if (entityName !== null) { + var lastChar = entityName[entityName.length - 1]; + if (lastChar != ";") { + tokenQueue.addLast({"type": tokenTypes["ParseError"], "data": + "named-entity-without-semicolon"}); + } + if (lastChar != ";" && fromAttribute && + (isLetterOrDigit(charStack[entityLen]) || + charStack[entityLen] == '=')) { + stream.unget(charStack.removeLast()); + output = "&${joinStr(charStack)}"; + } else { + output = entities[entityName]; + stream.unget(charStack.removeLast()); + output = '${output}${joinStr(slice(charStack, entityLen))}'; + } + } else { + tokenQueue.addLast({"type": tokenTypes["ParseError"], "data": + "expected-named-entity"}); + stream.unget(charStack.removeLast()); + output = "&${joinStr(charStack)}"; + } + } + if (fromAttribute) { + lastData[1] = '${lastData[1]}${output}'; + } else { + var tokenType; + if (isWhitespace(output)) { + tokenType = "SpaceCharacters"; + } else { + tokenType = "Characters"; + } + tokenQueue.addLast({"type": tokenTypes[tokenType], "data": output}); + } + } + + /** This method replaces the need for "entityInAttributeValueState". */ + void processEntityInAttribute(String allowedChar) { + consumeEntity(allowedChar: allowedChar, fromAttribute: true); + } + + /** + * This method is a generic handler for emitting the tags. It also sets + * the state to "data" because that's what's needed after a token has been + * emitted. + */ + void emitCurrentToken() { + var token = currentToken; + // Add token to the queue to be yielded + if (isTagTokenType(token["type"])) { + if (lowercaseElementName) { + token["name"] = asciiUpper2Lower(token["name"]); + } + if (token["type"] == tokenTypes["EndTag"]) { + if (token["data"].length > 0) { + tokenQueue.addLast({"type":tokenTypes["ParseError"], + "data":"attributes-in-end-tag"}); + } + if (token["selfClosing"]) { + tokenQueue.addLast({"type":tokenTypes["ParseError"], + "data":"this-closing-flag-on-end-tag"}); + } + } + } + tokenQueue.addLast(token); + state = dataState; + } + + + // Below are the various tokenizer states worked out. + + bool dataState() { + var data = stream.char(); + if (data == "&") { + state = entityDataState; + } else if (data == "<") { + state = tagOpenState; + } else if (data == "\u0000") { + tokenQueue.addLast({"type": tokenTypes["ParseError"], + "data":"invalid-codepoint"}); + tokenQueue.addLast({"type": tokenTypes["Characters"], + "data": "\u0000"}); + } else if (data === EOF) { + // Tokenization ends. + return false; + } else if (isWhitespace(data)) { + // Directly after emitting a token you switch back to the "data + // state". At that point spaceCharacters are important so they are + // emitted separately. + tokenQueue.addLast({"type": tokenTypes["SpaceCharacters"], "data": + '${data}${stream.charsUntil(spaceCharacters, true)}'}); + // No need to update lastFourChars here, since the first space will + // have already been appended to lastFourChars and will have broken + // any <!-- or --> sequences + } else { + var chars = stream.charsUntil("&<\u0000"); + tokenQueue.addLast({"type": tokenTypes["Characters"], "data": + '${data}${chars}'}); + } + return true; + } + + bool entityDataState() { + consumeEntity(); + state = dataState; + return true; + } + + bool rcdataState() { + var data = stream.char(); + if (data == "&") { + state = characterReferenceInRcdata; + } else if (data == "<") { + state = rcdataLessThanSignState; + } else if (data == EOF) { + // Tokenization ends. + return false; + } else if (data == "\u0000") { + tokenQueue.addLast({"type": tokenTypes["ParseError"], + "data": "invalid-codepoint"}); + tokenQueue.addLast({"type": tokenTypes["Characters"], + "data": "\uFFFD"}); + } else if (isWhitespace(data)) { + // Directly after emitting a token you switch back to the "data + // state". At that point spaceCharacters are important so they are + // emitted separately. + tokenQueue.addLast({"type": tokenTypes["SpaceCharacters"], "data": + '${data}${stream.charsUntil(spaceCharacters, true)}'}); + // No need to update lastFourChars here, since the first space will + // have already been appended to lastFourChars and will have broken + // any <!-- or --> sequences + } else { + var chars = stream.charsUntil("&<"); + tokenQueue.addLast({"type": tokenTypes["Characters"], "data": + '${data}${chars}'}); + } + return true; + } + + bool characterReferenceInRcdata() { + consumeEntity(); + state = rcdataState; + return true; + } + + bool rawtextState() { + var data = stream.char(); + if (data == "<") { + state = rawtextLessThanSignState; + } else if (data == "\u0000") { + tokenQueue.addLast({"type": tokenTypes["ParseError"], + "data": "invalid-codepoint"}); + tokenQueue.addLast({"type": tokenTypes["Characters"], + "data": "\uFFFD"}); + } else if (data == EOF) { + // Tokenization ends. + return false; + } else { + var chars = stream.charsUntil("<\u0000"); + tokenQueue.addLast({"type": tokenTypes["Characters"], "data": + '${data}${chars}'}); + } + return true; + } + + bool scriptDataState() { + var data = stream.char(); + if (data == "<") { + state = scriptDataLessThanSignState; + } else if (data == "\u0000") { + tokenQueue.addLast({"type": tokenTypes["ParseError"], + "data": "invalid-codepoint"}); + tokenQueue.addLast({"type": tokenTypes["Characters"], + "data": "\uFFFD"}); + } else if (data == EOF) { + // Tokenization ends. + return false; + } else { + var chars = stream.charsUntil("<\u0000"); + tokenQueue.addLast({"type": tokenTypes["Characters"], "data": + '${data}${chars}'}); + } + return true; + } + + bool plaintextState() { + var data = stream.char(); + if (data == EOF) { + // Tokenization ends. + return false; + } else if (data == "\u0000") { + tokenQueue.addLast({"type": tokenTypes["ParseError"], + "data": "invalid-codepoint"}); + tokenQueue.addLast({"type": tokenTypes["Characters"], + "data": "\uFFFD"}); + } else { + tokenQueue.addLast({"type": tokenTypes["Characters"], "data": + '${data}${stream.charsUntil("\u0000")}'}); + } + return true; + } + + bool tagOpenState() { + var data = stream.char(); + if (data == "!") { + state = markupDeclarationOpenState; + } else if (data == "/") { + state = closeTagOpenState; + } else if (isLetter(data)) { + currentToken = {"type": tokenTypes["StartTag"], + "name": data, "data": [], + "selfClosing": false, + "selfClosingAcknowledged": false}; + state = tagNameState; + } else if (data == ">") { + // XXX In theory it could be something besides a tag name. But + // do we really care? + tokenQueue.addLast({"type": tokenTypes["ParseError"], "data": + "expected-tag-name-but-got-right-bracket"}); + tokenQueue.addLast({"type": tokenTypes["Characters"], "data": "<>"}); + state = dataState; + } else if (data == "?") { + // XXX In theory it could be something besides a tag name. But + // do we really care? + tokenQueue.addLast({"type": tokenTypes["ParseError"], "data": + "expected-tag-name-but-got-question-mark"}); + stream.unget(data); + state = bogusCommentState; + } else { + // XXX + tokenQueue.addLast({"type": tokenTypes["ParseError"], "data": + "expected-tag-name"}); + tokenQueue.addLast({"type": tokenTypes["Characters"], "data": "<"}); + stream.unget(data); + state = dataState; + } + return true; + } + + bool closeTagOpenState() { + var data = stream.char(); + if (isLetter(data)) { + currentToken = {"type": tokenTypes["EndTag"], "name": data, + "data": [], "selfClosing":false}; + state = tagNameState; + } else if (data == ">") { + tokenQueue.addLast({"type": tokenTypes["ParseError"], "data": + "expected-closing-tag-but-got-right-bracket"}); + state = dataState; + } else if (data === EOF) { + tokenQueue.addLast({"type": tokenTypes["ParseError"], "data": + "expected-closing-tag-but-got-eof"}); + tokenQueue.addLast({"type": tokenTypes["Characters"], "data": "</"}); + state = dataState; + } else { + // XXX data can be _'_... + tokenQueue.addLast({"type": tokenTypes["ParseError"], "data": + "expected-closing-tag-but-got-char", + "datavars": {"data": data}}); + stream.unget(data); + state = bogusCommentState; + } + return true; + } + + bool tagNameState() { + var data = stream.char(); + if (isWhitespace(data)) { + state = beforeAttributeNameState; + } else if (data == ">") { + emitCurrentToken(); + } else if (data === EOF) { + tokenQueue.addLast({"type": tokenTypes["ParseError"], "data": + "eof-in-tag-name"}); + state = dataState; + } else if (data == "/") { + state = selfClosingStartTagState; + } else if (data == "\u0000") { + tokenQueue.addLast({"type": tokenTypes["ParseError"], + "data": "invalid-codepoint"}); + currentToken["name"] = '${currentToken["name"]}\uFFFD'; + } else { + currentToken["name"] = '${currentToken["name"]}${data}'; + // (Don't use charsUntil here, because tag names are + // very short and it's faster to not do anything fancy) + } + return true; + } + + bool rcdataLessThanSignState() { + var data = stream.char(); + if (data == "/") { + temporaryBuffer = ""; + state = rcdataEndTagOpenState; + } else { + tokenQueue.addLast({"type": tokenTypes["Characters"], "data": "<"}); + stream.unget(data); + state = rcdataState; + } + return true; + } + + bool rcdataEndTagOpenState() { + var data = stream.char(); + if (isLetter(data)) { + temporaryBuffer = '${temporaryBuffer}${data}'; + state = rcdataEndTagNameState; + } else { + tokenQueue.addLast({"type": tokenTypes["Characters"], "data": "</"}); + stream.unget(data); + state = rcdataState; + } + return true; + } + + bool _tokenIsAppropriate() { + return currentToken != null && + currentToken["name"].toLowerCase() == temporaryBuffer.toLowerCase(); + } + + bool rcdataEndTagNameState() { + var appropriate = _tokenIsAppropriate(); + var data = stream.char(); + if (isWhitespace(data) && appropriate) { + currentToken = {"type": tokenTypes["EndTag"], + "name": temporaryBuffer, + "data": [], "selfClosing":false}; + state = beforeAttributeNameState; + } else if (data == "/" && appropriate) { + currentToken = {"type": tokenTypes["EndTag"], + "name": temporaryBuffer, + "data": [], "selfClosing":false}; + state = selfClosingStartTagState; + } else if (data == ">" && appropriate) { + currentToken = {"type": tokenTypes["EndTag"], + "name": temporaryBuffer, + "data": [], "selfClosing":false}; + emitCurrentToken(); + state = dataState; + } else if (isLetter(data)) { + temporaryBuffer = '${temporaryBuffer}${data}'; + } else { + tokenQueue.addLast({"type": tokenTypes["Characters"], + "data": "</$temporaryBuffer"}); + stream.unget(data); + state = rcdataState; + } + return true; + } + + bool rawtextLessThanSignState() { + var data = stream.char(); + if (data == "/") { + temporaryBuffer = ""; + state = rawtextEndTagOpenState; + } else { + tokenQueue.addLast({"type": tokenTypes["Characters"], "data": "<"}); + stream.unget(data); + state = rawtextState; + } + return true; + } + + bool rawtextEndTagOpenState() { + var data = stream.char(); + if (isLetter(data)) { + temporaryBuffer = '${temporaryBuffer}${data}'; + state = rawtextEndTagNameState; + } else { + tokenQueue.addLast({"type": tokenTypes["Characters"], "data": "</"}); + stream.unget(data); + state = rawtextState; + } + return true; + } + + bool rawtextEndTagNameState() { + var appropriate = _tokenIsAppropriate(); + var data = stream.char(); + if (isWhitespace(data) && appropriate) { + currentToken = {"type": tokenTypes["EndTag"], + "name": temporaryBuffer, + "data": [], "selfClosing":false}; + state = beforeAttributeNameState; + } else if (data == "/" && appropriate) { + currentToken = {"type": tokenTypes["EndTag"], + "name": temporaryBuffer, + "data": [], "selfClosing":false}; + state = selfClosingStartTagState; + } else if (data == ">" && appropriate) { + currentToken = {"type": tokenTypes["EndTag"], + "name": temporaryBuffer, + "data": [], "selfClosing":false}; + emitCurrentToken(); + state = dataState; + } else if (isLetter(data)) { + temporaryBuffer = '${temporaryBuffer}${data}'; + } else { + tokenQueue.addLast({"type": tokenTypes["Characters"], + "data": "</$temporaryBuffer"}); + stream.unget(data); + state = rawtextState; + } + return true; + } + + bool scriptDataLessThanSignState() { + var data = stream.char(); + if (data == "/") { + temporaryBuffer = ""; + state = scriptDataEndTagOpenState; + } else if (data == "!") { + tokenQueue.addLast({"type": tokenTypes["Characters"], "data": "<!"}); + state = scriptDataEscapeStartState; + } else { + tokenQueue.addLast({"type": tokenTypes["Characters"], "data": "<"}); + stream.unget(data); + state = scriptDataState; + } + return true; + } + + bool scriptDataEndTagOpenState() { + var data = stream.char(); + if (isLetter(data)) { + temporaryBuffer = '${temporaryBuffer}${data}'; + state = scriptDataEndTagNameState; + } else { + tokenQueue.addLast({"type": tokenTypes["Characters"], "data": "</"}); + stream.unget(data); + state = scriptDataState; + } + return true; + } + + bool scriptDataEndTagNameState() { + var appropriate = _tokenIsAppropriate(); + var data = stream.char(); + if (isWhitespace(data) && appropriate) { + currentToken = {"type": tokenTypes["EndTag"], + "name": temporaryBuffer, + "data": [], "selfClosing":false}; + state = beforeAttributeNameState; + } else if (data == "/" && appropriate) { + currentToken = {"type": tokenTypes["EndTag"], + "name": temporaryBuffer, + "data": [], "selfClosing":false}; + state = selfClosingStartTagState; + } else if (data == ">" && appropriate) { + currentToken = {"type": tokenTypes["EndTag"], + "name": temporaryBuffer, + "data": [], "selfClosing":false}; + emitCurrentToken(); + state = dataState; + } else if (isLetter(data)) { + temporaryBuffer = '${temporaryBuffer}${data}'; + } else { + tokenQueue.addLast({"type": tokenTypes["Characters"], + "data": "</$temporaryBuffer"}); + stream.unget(data); + state = scriptDataState; + } + return true; + } + + bool scriptDataEscapeStartState() { + var data = stream.char(); + if (data == "-") { + tokenQueue.addLast({"type": tokenTypes["Characters"], "data": "-"}); + state = scriptDataEscapeStartDashState; + } else { + stream.unget(data); + state = scriptDataState; + } + return true; + } + + bool scriptDataEscapeStartDashState() { + var data = stream.char(); + if (data == "-") { + tokenQueue.addLast({"type": tokenTypes["Characters"], "data": "-"}); + state = scriptDataEscapedDashDashState; + } else { + stream.unget(data); + state = scriptDataState; + } + return true; + } + + bool scriptDataEscapedState() { + var data = stream.char(); + if (data == "-") { + tokenQueue.addLast({"type": tokenTypes["Characters"], "data": "-"}); + state = scriptDataEscapedDashState; + } else if (data == "<") { + state = scriptDataEscapedLessThanSignState; + } else if (data == "\u0000") { + tokenQueue.addLast({"type": tokenTypes["ParseError"], + "data": "invalid-codepoint"}); + tokenQueue.addLast({"type": tokenTypes["Characters"], + "data": "\uFFFD"}); + } else if (data == EOF) { + state = dataState; + } else { + var chars = stream.charsUntil("<-\u0000"); + tokenQueue.addLast({"type": tokenTypes["Characters"], "data": + '${data}${chars}'}); + } + return true; + } + + bool scriptDataEscapedDashState() { + var data = stream.char(); + if (data == "-") { + tokenQueue.addLast({"type": tokenTypes["Characters"], "data": "-"}); + state = scriptDataEscapedDashDashState; + } else if (data == "<") { + state = scriptDataEscapedLessThanSignState; + } else if (data == "\u0000") { + tokenQueue.addLast({"type": tokenTypes["ParseError"], + "data": "invalid-codepoint"}); + tokenQueue.addLast({"type": tokenTypes["Characters"], + "data": "\uFFFD"}); + state = scriptDataEscapedState; + } else if (data == EOF) { + state = dataState; + } else { + tokenQueue.addLast({"type": tokenTypes["Characters"], "data": data}); + state = scriptDataEscapedState; + } + return true; + } + + bool scriptDataEscapedDashDashState() { + var data = stream.char(); + if (data == "-") { + tokenQueue.addLast({"type": tokenTypes["Characters"], "data": "-"}); + } else if (data == "<") { + state = scriptDataEscapedLessThanSignState; + } else if (data == ">") { + tokenQueue.addLast({"type": tokenTypes["Characters"], "data": ">"}); + state = scriptDataState; + } else if (data == "\u0000") { + tokenQueue.addLast({"type": tokenTypes["ParseError"], + "data": "invalid-codepoint"}); + tokenQueue.addLast({"type": tokenTypes["Characters"], + "data": "\uFFFD"}); + state = scriptDataEscapedState; + } else if (data == EOF) { + state = dataState; + } else { + tokenQueue.addLast({"type": tokenTypes["Characters"], "data": data}); + state = scriptDataEscapedState; + } + return true; + } + + bool scriptDataEscapedLessThanSignState() { + var data = stream.char(); + if (data == "/") { + temporaryBuffer = ""; + state = scriptDataEscapedEndTagOpenState; + } else if (isLetter(data)) { + tokenQueue.addLast({"type": tokenTypes["Characters"], "data": "<$data"}); + temporaryBuffer = data; + state = scriptDataDoubleEscapeStartState; + } else { + tokenQueue.addLast({"type": tokenTypes["Characters"], "data": "<"}); + stream.unget(data); + state = scriptDataEscapedState; + } + return true; + } + + bool scriptDataEscapedEndTagOpenState() { + var data = stream.char(); + if (isLetter(data)) { + temporaryBuffer = data; + state = scriptDataEscapedEndTagNameState; + } else { + tokenQueue.addLast({"type": tokenTypes["Characters"], "data": "</"}); + stream.unget(data); + state = scriptDataEscapedState; + } + return true; + } + + bool scriptDataEscapedEndTagNameState() { + var appropriate = _tokenIsAppropriate(); + var data = stream.char(); + if (isWhitespace(data) && appropriate) { + currentToken = {"type": tokenTypes["EndTag"], + "name": temporaryBuffer, + "data": [], "selfClosing":false}; + state = beforeAttributeNameState; + } else if (data == "/" && appropriate) { + currentToken = {"type": tokenTypes["EndTag"], + "name": temporaryBuffer, + "data": [], "selfClosing":false}; + state = selfClosingStartTagState; + } else if (data == ">" && appropriate) { + currentToken = {"type": tokenTypes["EndTag"], + "name": temporaryBuffer, + "data": [], "selfClosing":false}; + emitCurrentToken(); + state = dataState; + } else if (isLetter(data)) { + temporaryBuffer = '${temporaryBuffer}${data}'; + } else { + tokenQueue.addLast({"type": tokenTypes["Characters"], + "data": "</$temporaryBuffer"}); + stream.unget(data); + state = scriptDataEscapedState; + } + return true; + } + + bool scriptDataDoubleEscapeStartState() { + var data = stream.char(); + if (isWhitespace(data) || data == "/" || data == ">") { + tokenQueue.addLast({"type": tokenTypes["Characters"], "data": data}); + if (temporaryBuffer.toLowerCase() == "script") { + state = scriptDataDoubleEscapedState; + } else { + state = scriptDataEscapedState; + } + } else if (isLetter(data)) { + tokenQueue.addLast({"type": tokenTypes["Characters"], "data": data}); + temporaryBuffer = '${temporaryBuffer}${data}'; + } else { + stream.unget(data); + state = scriptDataEscapedState; + } + return true; + } + + bool scriptDataDoubleEscapedState() { + var data = stream.char(); + if (data == "-") { + tokenQueue.addLast({"type": tokenTypes["Characters"], "data": "-"}); + state = scriptDataDoubleEscapedDashState; + } else if (data == "<") { + tokenQueue.addLast({"type": tokenTypes["Characters"], "data": "<"}); + state = scriptDataDoubleEscapedLessThanSignState; + } else if (data == "\u0000") { + tokenQueue.addLast({"type": tokenTypes["ParseError"], + "data": "invalid-codepoint"}); + tokenQueue.addLast({"type": tokenTypes["Characters"], + "data": "\uFFFD"}); + } else if (data == EOF) { + tokenQueue.addLast({"type": tokenTypes["ParseError"], "data": + "eof-in-script-in-script"}); + state = dataState; + } else { + tokenQueue.addLast({"type": tokenTypes["Characters"], "data": data}); + } + return true; + } + + bool scriptDataDoubleEscapedDashState() { + var data = stream.char(); + if (data == "-") { + tokenQueue.addLast({"type": tokenTypes["Characters"], "data": "-"}); + state = scriptDataDoubleEscapedDashDashState; + } else if (data == "<") { + tokenQueue.addLast({"type": tokenTypes["Characters"], "data": "<"}); + state = scriptDataDoubleEscapedLessThanSignState; + } else if (data == "\u0000") { + tokenQueue.addLast({"type": tokenTypes["ParseError"], + "data": "invalid-codepoint"}); + tokenQueue.addLast({"type": tokenTypes["Characters"], + "data": "\uFFFD"}); + state = scriptDataDoubleEscapedState; + } else if (data == EOF) { + tokenQueue.addLast({"type": tokenTypes["ParseError"], "data": + "eof-in-script-in-script"}); + state = dataState; + } else { + tokenQueue.addLast({"type": tokenTypes["Characters"], "data": data}); + state = scriptDataDoubleEscapedState; + } + return true; + } + + // TODO(jmesserly): report bug in original code + // (was "Dash" instead of "DashDash") + bool scriptDataDoubleEscapedDashDashState() { + var data = stream.char(); + if (data == "-") { + tokenQueue.addLast({"type": tokenTypes["Characters"], "data": "-"}); + } else if (data == "<") { + tokenQueue.addLast({"type": tokenTypes["Characters"], "data": "<"}); + state = scriptDataDoubleEscapedLessThanSignState; + } else if (data == ">") { + tokenQueue.addLast({"type": tokenTypes["Characters"], "data": ">"}); + state = scriptDataState; + } else if (data == "\u0000") { + tokenQueue.addLast({"type": tokenTypes["ParseError"], + "data": "invalid-codepoint"}); + tokenQueue.addLast({"type": tokenTypes["Characters"], + "data": "\uFFFD"}); + state = scriptDataDoubleEscapedState; + } else if (data == EOF) { + tokenQueue.addLast({"type": tokenTypes["ParseError"], "data": + "eof-in-script-in-script"}); + state = dataState; + } else { + tokenQueue.addLast({"type": tokenTypes["Characters"], "data": data}); + state = scriptDataDoubleEscapedState; + } + return true; + } + + bool scriptDataDoubleEscapedLessThanSignState() { + var data = stream.char(); + if (data == "/") { + tokenQueue.addLast({"type": tokenTypes["Characters"], "data": "/"}); + temporaryBuffer = ""; + state = scriptDataDoubleEscapeEndState; + } else { + stream.unget(data); + state = scriptDataDoubleEscapedState; + } + return true; + } + + bool scriptDataDoubleEscapeEndState() { + var data = stream.char(); + if (isWhitespace(data) || data == "/" || data == ">") { + tokenQueue.addLast({"type": tokenTypes["Characters"], "data": data}); + if (temporaryBuffer.toLowerCase() == "script") { + state = scriptDataEscapedState; + } else { + state = scriptDataDoubleEscapedState; + } + } else if (isLetter(data)) { + tokenQueue.addLast({"type": tokenTypes["Characters"], "data": data}); + temporaryBuffer = '${temporaryBuffer}${data}'; + } else { + stream.unget(data); + state = scriptDataDoubleEscapedState; + } + return true; + } + + bool beforeAttributeNameState() { + var data = stream.char(); + if (isWhitespace(data)) { + stream.charsUntil(spaceCharacters, true); + } else if (isLetter(data)) { + currentToken["data"].add([data, ""]); + state = attributeNameState; + } else if (data == ">") { + emitCurrentToken(); + } else if (data == "/") { + state = selfClosingStartTagState; + } else if (inStr(data, "'\"=<")) { + tokenQueue.addLast({"type": tokenTypes["ParseError"], "data": + "invalid-character-in-attribute-name"}); + currentToken["data"].add([data, ""]); + state = attributeNameState; + } else if (data == "\u0000") { + tokenQueue.addLast({"type": tokenTypes["ParseError"], + "data": "invalid-codepoint"}); + currentToken["data"].add(["\uFFFD", ""]); + state = attributeNameState; + } else if (data === EOF) { + tokenQueue.addLast({"type": tokenTypes["ParseError"], "data": + "expected-attribute-name-but-got-eof"}); + state = dataState; + } else { + currentToken["data"].add([data, ""]); + state = attributeNameState; + } + return true; + } + + bool attributeNameState() { + var data = stream.char(); + bool leavingThisState = true; + bool emitToken = false; + if (data == "=") { + state = beforeAttributeValueState; + } else if (isLetter(data)) { + lastData[0] = '${lastData[0]}${data}' + '${stream.charsUntil(asciiLetters, true)}'; + leavingThisState = false; + } else if (data == ">") { + // XXX If we emit here the attributes are converted to a dict + // without being checked and when the code below runs we error + // because data is a dict not a list + emitToken = true; + } else if (isWhitespace(data)) { + state = afterAttributeNameState; + } else if (data == "/") { + state = selfClosingStartTagState; + } else if (data == "\u0000") { + tokenQueue.addLast({"type": tokenTypes["ParseError"], + "data": "invalid-codepoint"}); + lastData[0] = '${lastData[0]}\uFFFD'; + leavingThisState = false; + } else if (inStr(data, "'\"<")) { + tokenQueue.addLast({"type": tokenTypes["ParseError"], + "data": "invalid-character-in-attribute-name"}); + lastData[0] = '${lastData[0]}${data}'; + leavingThisState = false; + } else if (data === EOF) { + tokenQueue.addLast({"type": tokenTypes["ParseError"], + "data": "eof-in-attribute-name"}); + state = dataState; + } else { + lastData[0] = '${lastData[0]}${data}'; + leavingThisState = false; + } + + if (leavingThisState) { + // Attributes are not dropped at this stage. That happens when the + // start tag token is emitted so values can still be safely appended + // to attributes, but we do want to report the parse error in time. + if (lowercaseAttrName) { + lastData[0] = asciiUpper2Lower(lastData[0]); + } + for (int i = 0; i < currentToken["data"].length - 1; i++) { + var name = currentToken["data"][i][0]; + if (lastData[0] == name) { + tokenQueue.addLast({"type": tokenTypes["ParseError"], "data": + "duplicate-attribute"}); + break; + } + } + // XXX Fix for above XXX + if (emitToken) { + emitCurrentToken(); + } + } + return true; + } + + bool afterAttributeNameState() { + var data = stream.char(); + if (isWhitespace(data)) { + stream.charsUntil(spaceCharacters, true); + } else if (data == "=") { + state = beforeAttributeValueState; + } else if (data == ">") { + emitCurrentToken(); + } else if (isLetter(data)) { + currentToken["data"].add([data, ""]); + state = attributeNameState; + } else if (data == "/") { + state = selfClosingStartTagState; + } else if (data == "\u0000") { + tokenQueue.addLast({"type": tokenTypes["ParseError"], + "data": "invalid-codepoint"}); + currentToken["data"].add(["\uFFFD", ""]); + state = attributeNameState; + } else if (inStr(data, "'\"<")) { + tokenQueue.addLast({"type": tokenTypes["ParseError"], "data": + "invalid-character-after-attribute-name"}); + currentToken["data"].add([data, ""]); + state = attributeNameState; + } else if (data === EOF) { + tokenQueue.addLast({"type": tokenTypes["ParseError"], "data": + "expected-end-of-tag-but-got-eof"}); + state = dataState; + } else { + currentToken["data"].add([data, ""]); + state = attributeNameState; + } + return true; + } + + bool beforeAttributeValueState() { + var data = stream.char(); + if (isWhitespace(data)) { + stream.charsUntil(spaceCharacters, true); + } else if (data == "\"") { + state = attributeValueDoubleQuotedState; + } else if (data == "&") { + state = attributeValueUnQuotedState; + stream.unget(data); + } else if (data == "'") { + state = attributeValueSingleQuotedState; + } else if (data == ">") { + tokenQueue.addLast({"type": tokenTypes["ParseError"], "data": + "expected-attribute-value-but-got-right-bracket"}); + emitCurrentToken(); + } else if (data == "\u0000") { + tokenQueue.addLast({"type": tokenTypes["ParseError"], + "data": "invalid-codepoint"}); + lastData[1] = '${lastData[1]}\uFFFD'; + state = attributeValueUnQuotedState; + } else if (inStr(data, "=<`")) { + tokenQueue.addLast({"type": tokenTypes["ParseError"], "data": + "equals-in-unquoted-attribute-value"}); + lastData[1] = '${lastData[1]}${data}'; + state = attributeValueUnQuotedState; + } else if (data === EOF) { + tokenQueue.addLast({"type": tokenTypes["ParseError"], "data": + "expected-attribute-value-but-got-eof"}); + state = dataState; + } else { + lastData[1] = '${lastData[1]}${data}'; + state = attributeValueUnQuotedState; + } + return true; + } + + bool attributeValueDoubleQuotedState() { + var data = stream.char(); + if (data == "\"") { + state = afterAttributeValueState; + } else if (data == "&") { + processEntityInAttribute('"'); + } else if (data == "\u0000") { + tokenQueue.addLast({"type": tokenTypes["ParseError"], + "data": "invalid-codepoint"}); + lastData[1] = '${lastData[1]}\uFFFD'; + } else if (data === EOF) { + tokenQueue.addLast({"type": tokenTypes["ParseError"], "data": + "eof-in-attribute-value-double-quote"}); + state = dataState; + } else { + lastData[1] = '${lastData[1]}${data}' + '${stream.charsUntil("\"&")}'; + } + return true; + } + + bool attributeValueSingleQuotedState() { + var data = stream.char(); + if (data == "'") { + state = afterAttributeValueState; + } else if (data == "&") { + processEntityInAttribute("'"); + } else if (data == "\u0000") { + tokenQueue.addLast({"type": tokenTypes["ParseError"], + "data": "invalid-codepoint"}); + lastData[1] = '${lastData[1]}\uFFFD'; + } else if (data === EOF) { + tokenQueue.addLast({"type": tokenTypes["ParseError"], "data": + "eof-in-attribute-value-single-quote"}); + state = dataState; + } else { + lastData[1] = '${lastData[1]}${data}' + '${stream.charsUntil("\'&")}'; + } + return true; + } + + bool attributeValueUnQuotedState() { + var data = stream.char(); + if (isWhitespace(data)) { + state = beforeAttributeNameState; + } else if (data == "&") { + processEntityInAttribute(">"); + } else if (data == ">") { + emitCurrentToken(); + } else if (inStr(data, '"\'=<`')) { + tokenQueue.addLast({"type": tokenTypes["ParseError"], "data": + "unexpected-character-in-unquoted-attribute-value"}); + lastData[1] = '${lastData[1]}${data}'; + } else if (data == "\u0000") { + tokenQueue.addLast({"type": tokenTypes["ParseError"], + "data": "invalid-codepoint"}); + lastData[1] = '${lastData[1]}\uFFFD'; + } else if (data === EOF) { + tokenQueue.addLast({"type": tokenTypes["ParseError"], "data": + "eof-in-attribute-value-no-quotes"}); + state = dataState; + } else { + lastData[1] = '${lastData[1]}${data}' + '${stream.charsUntil("&>\"\'=<`$spaceCharacters")}'; + } + return true; + } + + bool afterAttributeValueState() { + var data = stream.char(); + if (isWhitespace(data)) { + state = beforeAttributeNameState; + } else if (data == ">") { + emitCurrentToken(); + } else if (data == "/") { + state = selfClosingStartTagState; + } else if (data === EOF) { + tokenQueue.addLast({"type": tokenTypes["ParseError"], "data": + "unexpected-EOF-after-attribute-value"}); + stream.unget(data); + state = dataState; + } else { + tokenQueue.addLast({"type": tokenTypes["ParseError"], "data": + "unexpected-character-after-attribute-value"}); + stream.unget(data); + state = beforeAttributeNameState; + } + return true; + } + + bool selfClosingStartTagState() { + var data = stream.char(); + if (data == ">") { + currentToken["selfClosing"] = true; + emitCurrentToken(); + } else if (data === EOF) { + tokenQueue.addLast({"type": tokenTypes["ParseError"], + "data": "unexpected-EOF-after-solidus-in-tag"}); + stream.unget(data); + state = dataState; + } else { + tokenQueue.addLast({"type": tokenTypes["ParseError"], "data": + "unexpected-character-after-soldius-in-tag"}); + stream.unget(data); + state = beforeAttributeNameState; + } + return true; + } + + bool bogusCommentState() { + // Make a new comment token and give it as value all the characters + // until the first > or EOF (charsUntil checks for EOF automatically) + // and emit it. + var data = stream.charsUntil(">"); + data = data.replaceAll("\u0000", "\uFFFD"); + tokenQueue.addLast({"type": tokenTypes["Comment"], "data": data}); + + // Eat the character directly after the bogus comment which is either a + // ">" or an EOF. + stream.char(); + state = dataState; + return true; + } + + bool markupDeclarationOpenState() { + var charStack = [stream.char()]; + if (charStack.last() == "-") { + charStack.add(stream.char()); + if (charStack.last() == "-") { + currentToken = {"type": tokenTypes["Comment"], "data": ""}; + state = commentStartState; + return true; + } + } else if (charStack.last() == 'd' || charStack.last() == 'D') { + var matched = true; + for (var expected in const ['oO', 'cC', 'tT', 'yY', 'pP', 'eE']) { + charStack.add(stream.char()); + if (!inStr(charStack.last(), expected)) { + matched = false; + break; + } + } + if (matched) { + currentToken = {"type": tokenTypes["Doctype"], + "name": "", + "publicId": null, "systemId": null, + "correct": true}; + state = doctypeState; + return true; + } + } else if (charStack.last() == "[" && + parser !== null && parser.tree.openElements != null && + parser.tree.openElements.last().namespace + != parser.tree.defaultNamespace) { + var matched = true; + for (var expected in const ["C", "D", "A", "T", "A", "["]) { + charStack.add(stream.char()); + if (charStack.last() != expected) { + matched = false; + break; + } + } + if (matched) { + state = cdataSectionState; + return true; + } + } + + tokenQueue.addLast({"type": tokenTypes["ParseError"], "data": + "expected-dashes-or-doctype"}); + + while (charStack.length > 0) { + stream.unget(charStack.removeLast()); + } + state = bogusCommentState; + return true; + } + + bool commentStartState() { + var data = stream.char(); + if (data == "-") { + state = commentStartDashState; + } else if (data == "\u0000") { + tokenQueue.addLast({"type": tokenTypes["ParseError"], + "data": "invalid-codepoint"}); + currentToken["data"] = '${currentToken["data"]}\uFFFD'; + } else if (data == ">") { + tokenQueue.addLast({"type": tokenTypes["ParseError"], "data": + "incorrect-comment"}); + tokenQueue.addLast(currentToken); + state = dataState; + } else if (data === EOF) { + tokenQueue.addLast({"type": tokenTypes["ParseError"], "data": + "eof-in-comment"}); + tokenQueue.addLast(currentToken); + state = dataState; + } else { + currentToken["data"] = '${currentToken["data"]}${data}'; + state = commentState; + } + return true; + } + + bool commentStartDashState() { + var data = stream.char(); + if (data == "-") { + state = commentEndState; + } else if (data == "\u0000") { + tokenQueue.addLast({"type": tokenTypes["ParseError"], + "data": "invalid-codepoint"}); + currentToken["data"] = '${currentToken["data"]}-\uFFFD'; + } else if (data == ">") { + tokenQueue.addLast({"type": tokenTypes["ParseError"], "data": + "incorrect-comment"}); + tokenQueue.addLast(currentToken); + state = dataState; + } else if (data === EOF) { + tokenQueue.addLast({"type": tokenTypes["ParseError"], "data": + "eof-in-comment"}); + tokenQueue.addLast(currentToken); + state = dataState; + } else { + currentToken["data"] = '${currentToken["data"]}-${data}'; + state = commentState; + } + return true; + } + + bool commentState() { + var data = stream.char(); + if (data == "-") { + state = commentEndDashState; + } else if (data == "\u0000") { + tokenQueue.addLast({"type": tokenTypes["ParseError"], + "data": "invalid-codepoint"}); + currentToken["data"] = '${currentToken["data"]}\uFFFD'; + } else if (data === EOF) { + tokenQueue.addLast({"type": tokenTypes["ParseError"], + "data": "eof-in-comment"}); + tokenQueue.addLast(currentToken); + state = dataState; + } else { + currentToken["data"] = '${currentToken["data"]}${data}' + '${stream.charsUntil("-\u0000")}'; + } + return true; + } + + bool commentEndDashState() { + var data = stream.char(); + if (data == "-") { + state = commentEndState; + } else if (data == "\u0000") { + tokenQueue.addLast({"type": tokenTypes["ParseError"], + "data": "invalid-codepoint"}); + currentToken["data"] = "${currentToken["data"]}-\uFFFD"; + state = commentState; + } else if (data === EOF) { + tokenQueue.addLast({"type": tokenTypes["ParseError"], "data": + "eof-in-comment-end-dash"}); + tokenQueue.addLast(currentToken); + state = dataState; + } else { + currentToken["data"] = "${currentToken["data"]}-${data}"; + state = commentState; + } + return true; + } + + bool commentEndState() { + var data = stream.char(); + if (data == ">") { + tokenQueue.addLast(currentToken); + state = dataState; + } else if (data == "\u0000") { + tokenQueue.addLast({"type": tokenTypes["ParseError"], + "data": "invalid-codepoint"}); + currentToken["data"] = '${currentToken["data"]}--\uFFFD'; + state = commentState; + } else if (data == "!") { + tokenQueue.addLast({"type": tokenTypes["ParseError"], "data": + "unexpected-bang-after-double-dash-in-comment"}); + state = commentEndBangState; + } else if (data == "-") { + tokenQueue.addLast({"type": tokenTypes["ParseError"], "data": + "unexpected-dash-after-double-dash-in-comment"}); + currentToken["data"] = '${currentToken["data"]}${data}'; + } else if (data === EOF) { + tokenQueue.addLast({"type": tokenTypes["ParseError"], "data": + "eof-in-comment-double-dash"}); + tokenQueue.addLast(currentToken); + state = dataState; + } else { + // XXX + tokenQueue.addLast({"type": tokenTypes["ParseError"], "data": + "unexpected-char-in-comment"}); + currentToken["data"] = "${currentToken["data"]}--${data}"; + state = commentState; + } + return true; + } + + bool commentEndBangState() { + var data = stream.char(); + if (data == ">") { + tokenQueue.addLast(currentToken); + state = dataState; + } else if (data == "-") { + currentToken["data"] = '${currentToken["data"]}--!'; + state = commentEndDashState; + } else if (data == "\u0000") { + tokenQueue.addLast({"type": tokenTypes["ParseError"], + "data": "invalid-codepoint"}); + currentToken["data"] = '${currentToken["data"]}--!\uFFFD'; + state = commentState; + } else if (data === EOF) { + tokenQueue.addLast({"type": tokenTypes["ParseError"], "data": + "eof-in-comment-end-bang-state"}); + tokenQueue.addLast(currentToken); + state = dataState; + } else { + currentToken["data"] = "${currentToken["data"]}--!${data}"; + state = commentState; + } + return true; + } + + bool doctypeState() { + var data = stream.char(); + if (isWhitespace(data)) { + state = beforeDoctypeNameState; + } else if (data === EOF) { + tokenQueue.addLast({"type": tokenTypes["ParseError"], "data": + "expected-doctype-name-but-got-eof"}); + currentToken["correct"] = false; + tokenQueue.addLast(currentToken); + state = dataState; + } else { + tokenQueue.addLast({"type": tokenTypes["ParseError"], "data": + "need-space-after-doctype"}); + stream.unget(data); + state = beforeDoctypeNameState; + } + return true; + } + + bool beforeDoctypeNameState() { + var data = stream.char(); + if (isWhitespace(data)) { + return true; + } else if (data == ">") { + tokenQueue.addLast({"type": tokenTypes["ParseError"], "data": + "expected-doctype-name-but-got-right-bracket"}); + currentToken["correct"] = false; + tokenQueue.addLast(currentToken); + state = dataState; + } else if (data == "\u0000") { + tokenQueue.addLast({"type": tokenTypes["ParseError"], + "data": "invalid-codepoint"}); + currentToken["name"] = "\uFFFD"; + state = doctypeNameState; + } else if (data === EOF) { + tokenQueue.addLast({"type": tokenTypes["ParseError"], "data": + "expected-doctype-name-but-got-eof"}); + currentToken["correct"] = false; + tokenQueue.addLast(currentToken); + state = dataState; + } else { + currentToken["name"] = data; + state = doctypeNameState; + } + return true; + } + + bool doctypeNameState() { + var data = stream.char(); + if (isWhitespace(data)) { + currentToken["name"] = asciiUpper2Lower(currentToken["name"]); + state = afterDoctypeNameState; + } else if (data == ">") { + currentToken["name"] = asciiUpper2Lower(currentToken["name"]); + tokenQueue.addLast(currentToken); + state = dataState; + } else if (data == "\u0000") { + tokenQueue.addLast({"type": tokenTypes["ParseError"], + "data": "invalid-codepoint"}); + currentToken["name"] = "${currentToken["name"]}\uFFFD"; + state = doctypeNameState; + } else if (data === EOF) { + tokenQueue.addLast({"type": tokenTypes["ParseError"], "data": + "eof-in-doctype-name"}); + currentToken["correct"] = false; + currentToken["name"] = asciiUpper2Lower(currentToken["name"]); + tokenQueue.addLast(currentToken); + state = dataState; + } else { + currentToken["name"] = '${currentToken["name"]}${data}'; + } + return true; + } + + bool afterDoctypeNameState() { + var data = stream.char(); + if (isWhitespace(data)) { + return true; + } else if (data == ">") { + tokenQueue.addLast(currentToken); + state = dataState; + } else if (data === EOF) { + currentToken["correct"] = false; + stream.unget(data); + tokenQueue.addLast({"type": tokenTypes["ParseError"], "data": + "eof-in-doctype"}); + tokenQueue.addLast(currentToken); + state = dataState; + } else { + if (data == "p" || data == "P") { + var matched = true; + for (var expected in const ["uU", "bB", "lL", "iI", "cC"]) { + data = stream.char(); + if (!inStr(data, expected)) { + matched = false; + break; + } + } + if (matched) { + state = afterDoctypePublicKeywordState; + return true; + } + } else if (data == "s" || data == "S") { + var matched = true; + for (var expected in const ["yY", "sS", "tT", "eE", "mM"]) { + data = stream.char(); + if (!inStr(data, expected)) { + matched = false; + break; + } + } + if (matched) { + state = afterDoctypeSystemKeywordState; + return true; + } + } + + // All the characters read before the current 'data' will be + // [a-zA-Z], so they're garbage in the bogus doctype and can be + // discarded; only the latest character might be '>' or EOF + // and needs to be ungetted + stream.unget(data); + tokenQueue.addLast({"type": tokenTypes["ParseError"], + "data": "expected-space-or-right-bracket-in-doctype", + "datavars": {"data": data}}); + currentToken["correct"] = false; + state = bogusDoctypeState; + } + return true; + } + + bool afterDoctypePublicKeywordState() { + var data = stream.char(); + if (isWhitespace(data)) { + state = beforeDoctypePublicIdentifierState; + } else if (data == "'" || data == '"') { + tokenQueue.addLast({"type": tokenTypes["ParseError"], "data": + "unexpected-char-in-doctype"}); + stream.unget(data); + state = beforeDoctypePublicIdentifierState; + } else if (data === EOF) { + tokenQueue.addLast({"type": tokenTypes["ParseError"], "data": + "eof-in-doctype"}); + currentToken["correct"] = false; + tokenQueue.addLast(currentToken); + state = dataState; + } else { + stream.unget(data); + state = beforeDoctypePublicIdentifierState; + } + return true; + } + + bool beforeDoctypePublicIdentifierState() { + var data = stream.char(); + if (isWhitespace(data)) { + return true; + } else if (data == "\"") { + currentToken["publicId"] = ""; + state = doctypePublicIdentifierDoubleQuotedState; + } else if (data == "'") { + currentToken["publicId"] = ""; + state = doctypePublicIdentifierSingleQuotedState; + } else if (data == ">") { + tokenQueue.addLast({"type": tokenTypes["ParseError"], "data": + "unexpected-end-of-doctype"}); + currentToken["correct"] = false; + tokenQueue.addLast(currentToken); + state = dataState; + } else if (data === EOF) { + tokenQueue.addLast({"type": tokenTypes["ParseError"], "data": + "eof-in-doctype"}); + currentToken["correct"] = false; + tokenQueue.addLast(currentToken); + state = dataState; + } else { + tokenQueue.addLast({"type": tokenTypes["ParseError"], "data": + "unexpected-char-in-doctype"}); + currentToken["correct"] = false; + state = bogusDoctypeState; + } + return true; + } + + bool doctypePublicIdentifierDoubleQuotedState() { + var data = stream.char(); + if (data == '"') { + state = afterDoctypePublicIdentifierState; + } else if (data == "\u0000") { + tokenQueue.addLast({"type": tokenTypes["ParseError"], + "data": "invalid-codepoint"}); + currentToken["publicId"] = "${currentToken["publicId"]}\uFFFD"; + } else if (data == ">") { + tokenQueue.addLast({"type": tokenTypes["ParseError"], "data": + "unexpected-end-of-doctype"}); + currentToken["correct"] = false; + tokenQueue.addLast(currentToken); + state = dataState; + } else if (data === EOF) { + tokenQueue.addLast({"type": tokenTypes["ParseError"], "data": + "eof-in-doctype"}); + currentToken["correct"] = false; + tokenQueue.addLast(currentToken); + state = dataState; + } else { + currentToken["publicId"] = '${currentToken["publicId"]}${data}'; + } + return true; + } + + bool doctypePublicIdentifierSingleQuotedState() { + var data = stream.char(); + if (data == "'") { + state = afterDoctypePublicIdentifierState; + } else if (data == "\u0000") { + tokenQueue.addLast({"type": tokenTypes["ParseError"], + "data": "invalid-codepoint"}); + currentToken["publicId"] = "${currentToken["publicId"]}\uFFFD"; + } else if (data == ">") { + tokenQueue.addLast({"type": tokenTypes["ParseError"], "data": + "unexpected-end-of-doctype"}); + currentToken["correct"] = false; + tokenQueue.addLast(currentToken); + state = dataState; + } else if (data === EOF) { + tokenQueue.addLast({"type": tokenTypes["ParseError"], "data": + "eof-in-doctype"}); + currentToken["correct"] = false; + tokenQueue.addLast(currentToken); + state = dataState; + } else { + currentToken["publicId"] = '${currentToken["publicId"]}${data}'; + } + return true; + } + + bool afterDoctypePublicIdentifierState() { + var data = stream.char(); + if (isWhitespace(data)) { + state = betweenDoctypePublicAndSystemIdentifiersState; + } else if (data == ">") { + tokenQueue.addLast(currentToken); + state = dataState; + } else if (data == '"') { + tokenQueue.addLast({"type": tokenTypes["ParseError"], "data": + "unexpected-char-in-doctype"}); + currentToken["systemId"] = ""; + state = doctypeSystemIdentifierDoubleQuotedState; + } else if (data == "'") { + tokenQueue.addLast({"type": tokenTypes["ParseError"], "data": + "unexpected-char-in-doctype"}); + currentToken["systemId"] = ""; + state = doctypeSystemIdentifierSingleQuotedState; + } else if (data === EOF) { + tokenQueue.addLast({"type": tokenTypes["ParseError"], "data": + "eof-in-doctype"}); + currentToken["correct"] = false; + tokenQueue.addLast(currentToken); + state = dataState; + } else { + tokenQueue.addLast({"type": tokenTypes["ParseError"], "data": + "unexpected-char-in-doctype"}); + currentToken["correct"] = false; + state = bogusDoctypeState; + } + return true; + } + + bool betweenDoctypePublicAndSystemIdentifiersState() { + var data = stream.char(); + if (isWhitespace(data)) { + return true; + } else if (data == ">") { + tokenQueue.addLast(currentToken); + state = dataState; + } else if (data == '"') { + currentToken["systemId"] = ""; + state = doctypeSystemIdentifierDoubleQuotedState; + } else if (data == "'") { + currentToken["systemId"] = ""; + state = doctypeSystemIdentifierSingleQuotedState; + } else if (data == EOF) { + tokenQueue.addLast({"type": tokenTypes["ParseError"], "data": + "eof-in-doctype"}); + currentToken["correct"] = false; + tokenQueue.addLast(currentToken); + state = dataState; + } else { + tokenQueue.addLast({"type": tokenTypes["ParseError"], "data": + "unexpected-char-in-doctype"}); + currentToken["correct"] = false; + state = bogusDoctypeState; + } + return true; + } + + bool afterDoctypeSystemKeywordState() { + var data = stream.char(); + if (isWhitespace(data)) { + state = beforeDoctypeSystemIdentifierState; + } else if (data == "'" || data == '"') { + tokenQueue.addLast({"type": tokenTypes["ParseError"], "data": + "unexpected-char-in-doctype"}); + stream.unget(data); + state = beforeDoctypeSystemIdentifierState; + } else if (data === EOF) { + tokenQueue.addLast({"type": tokenTypes["ParseError"], "data": + "eof-in-doctype"}); + currentToken["correct"] = false; + tokenQueue.addLast(currentToken); + state = dataState; + } else { + stream.unget(data); + state = beforeDoctypeSystemIdentifierState; + } + return true; + } + + bool beforeDoctypeSystemIdentifierState() { + var data = stream.char(); + if (isWhitespace(data)) { + return true; + } else if (data == "\"") { + currentToken["systemId"] = ""; + state = doctypeSystemIdentifierDoubleQuotedState; + } else if (data == "'") { + currentToken["systemId"] = ""; + state = doctypeSystemIdentifierSingleQuotedState; + } else if (data == ">") { + tokenQueue.addLast({"type": tokenTypes["ParseError"], "data": + "unexpected-char-in-doctype"}); + currentToken["correct"] = false; + tokenQueue.addLast(currentToken); + state = dataState; + } else if (data === EOF) { + tokenQueue.addLast({"type": tokenTypes["ParseError"], "data": + "eof-in-doctype"}); + currentToken["correct"] = false; + tokenQueue.addLast(currentToken); + state = dataState; + } else { + tokenQueue.addLast({"type": tokenTypes["ParseError"], "data": + "unexpected-char-in-doctype"}); + currentToken["correct"] = false; + state = bogusDoctypeState; + } + return true; + } + + bool doctypeSystemIdentifierDoubleQuotedState() { + var data = stream.char(); + if (data == "\"") { + state = afterDoctypeSystemIdentifierState; + } else if (data == "\u0000") { + tokenQueue.addLast({"type": tokenTypes["ParseError"], + "data": "invalid-codepoint"}); + currentToken["systemId"] = "${currentToken["systemId"]}\uFFFD"; + } else if (data == ">") { + tokenQueue.addLast({"type": tokenTypes["ParseError"], "data": + "unexpected-end-of-doctype"}); + currentToken["correct"] = false; + tokenQueue.addLast(currentToken); + state = dataState; + } else if (data === EOF) { + tokenQueue.addLast({"type": tokenTypes["ParseError"], "data": + "eof-in-doctype"}); + currentToken["correct"] = false; + tokenQueue.addLast(currentToken); + state = dataState; + } else { + currentToken["systemId"] = '${currentToken["systemId"]}${data}'; + } + return true; + } + + bool doctypeSystemIdentifierSingleQuotedState() { + var data = stream.char(); + if (data == "'") { + state = afterDoctypeSystemIdentifierState; + } else if (data == "\u0000") { + tokenQueue.addLast({"type": tokenTypes["ParseError"], + "data": "invalid-codepoint"}); + currentToken["systemId"] = "${currentToken["systemId"]}\uFFFD"; + } else if (data == ">") { + tokenQueue.addLast({"type": tokenTypes["ParseError"], "data": + "unexpected-end-of-doctype"}); + currentToken["correct"] = false; + tokenQueue.addLast(currentToken); + state = dataState; + } else if (data === EOF) { + tokenQueue.addLast({"type": tokenTypes["ParseError"], "data": + "eof-in-doctype"}); + currentToken["correct"] = false; + tokenQueue.addLast(currentToken); + state = dataState; + } else { + currentToken["systemId"] = '${currentToken["systemId"]}${data}'; + } + return true; + } + + bool afterDoctypeSystemIdentifierState() { + var data = stream.char(); + if (isWhitespace(data)) { + return true; + } else if (data == ">") { + tokenQueue.addLast(currentToken); + state = dataState; + } else if (data === EOF) { + tokenQueue.addLast({"type": tokenTypes["ParseError"], "data": + "eof-in-doctype"}); + currentToken["correct"] = false; + tokenQueue.addLast(currentToken); + state = dataState; + } else { + tokenQueue.addLast({"type": tokenTypes["ParseError"], "data": + "unexpected-char-in-doctype"}); + state = bogusDoctypeState; + } + return true; + } + + bool bogusDoctypeState() { + var data = stream.char(); + if (data == ">") { + tokenQueue.addLast(currentToken); + state = dataState; + } else if (data === EOF) { + // XXX EMIT + stream.unget(data); + tokenQueue.addLast(currentToken); + state = dataState; + } + return true; + } + + bool cdataSectionState() { + var data = []; + while (true) { + data.add(stream.charsUntil("]")); + var charStack = []; + + bool matched = false; + for (var expected in const ["]", "]", ">"]) { + charStack.add(stream.char()); + matched = true; + if (charStack.last() == EOF) { + data.addAll(slice(charStack, 0, -1)); + break; + } else if (charStack.last() != expected) { + matched = false; + data.addAll(charStack); + break; + } + } + + if (matched) { + break; + } + } + + var dataStr = joinStr(data); + // Deal with null here rather than in the parser + var nullCount = data.filter((c) => c == "\u0000").length; + if (nullCount > 0) { + for (int i = 0; i < nullCount; i++) { + tokenQueue.addLast({"type": tokenTypes["ParseError"], + "data": "invalid-codepoint"}); + } + dataStr = dataStr.replaceAll("\u0000", "\uFFFD"); + } + if (dataStr.length > 0) { + tokenQueue.addLast({"type": tokenTypes["Characters"], + "data": dataStr}); + } + state = dataState; + return true; + } +} + diff --git a/utils.dart b/utils.dart new file mode 100644 index 0000000..3733c5e --- /dev/null +++ b/utils.dart @@ -0,0 +1,57 @@ +/** Misc things that were useful when porting the code from Python. */ +#library('utils'); + +#import('constants.dart'); + +class Pair<F extends Hashable, S extends Hashable> implements Hashable { + final F first; + final S second; + + const Pair(this.first, this.second); + + int hashCode() => 37 * first.hashCode() + second.hashCode(); + operator ==(other) => other.first == first && other.second == second; +} + +int parseIntRadix(String str, [int radix = 10]) { + int val = 0; + for (int i = 0; i < str.length; i++) { + var digit = str.charCodeAt(i); + if (digit >= LOWER_A) { + digit += 10 - LOWER_A; + } else if (digit >= UPPER_A) { + digit += 10 - UPPER_A; + } else { + digit -= ZERO; + } + val = val * radix + digit; + } + return val; +} + +/** Simple way of testing if [char] is in [characters]. */ +bool inStr(String char, String characters) { + if (char == null) return false; + return characters.indexOf(char) >= 0; +} + +String joinStr(List<String> strings) => Strings.join(strings, ''); + +// Like the python [:] operator. +List slice(List list, int start, [int end]) { + if (end == null) end = list.length; + if (end < 0) end += list.length; + + // Ensure the indexes are in bounds. + if (end < start) end = start; + if (end > list.length) end = list.length; + return list.getRange(start, end - start); +} + +removeAt(List list, int i) { + var result = list[i]; + list.removeRange(i, 1); + return result; +} + +typedef bool Predicate();